Update to Chromium version 70.0.3538.0 (#587811)

Known issues:
- The CefLoadCRLSetsFile function needs to be re-implemented (see issue #2497).
- Linux: GTK2 support has been removed. The cefclient sample needs to be updated
  to use GTK3 (see issue #2014).

libcef/common/extensions/api/BUILD.gn

@@ -18,20 +18,18 @@ import("//tools/json_schema_compiler/json_features.gni")
 #schema_include_rules = "//cef/libcef/browser/extensions/api:extensions::api::cef::%(namespace)s"
 #schema_dependencies = [ "//extensions/common/api" ]
 #
-#json_schema_api("api") {
+#generated_json_strings("api") {
 #  sources = schema_sources
 #  schemas = true
-#  bundle = true
 #  configs = [ "//build/config:precompiled_headers" ]
 #  bundle_name = "Cef"
 #
 #  deps = schema_dependencies
 #}
 #
-#json_schema_api("api_registration") {
+#function_registration("api_registration") {
 #  sources = schema_sources
 #  impl_dir = "//cef/libcef/browser/extensions/api"
-#  bundle_registration = true
 #  configs = [ "//build/config:precompiled_headers" ]
 #  bundle_name = "Cef"
 #

libcef/common/extensions/extensions_api_provider.cc

@@ -0,0 +1,89 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libcef/common/extensions/extensions_api_provider.h"
+
+#include "libcef/common/extensions/chrome_generated_schemas.h"
+
+#include "cef/grit/cef_resources.h"
+//#include "cef/libcef/common/extensions/api/generated_schemas.h"
+#include "cef/libcef/common/extensions/api/cef_api_features.h"
+#include "cef/libcef/common/extensions/api/cef_manifest_features.h"
+#include "cef/libcef/common/extensions/api/cef_permission_features.h"
+#include "chrome/common/extensions/chrome_aliases.h"
+#include "chrome/common/extensions/chrome_manifest_handlers.h"
+#include "extensions/common/features/json_feature_provider_source.h"
+#include "extensions/common/permissions/permissions_info.h"
+
+namespace extensions {
+
+CefExtensionsAPIProvider::CefExtensionsAPIProvider() {
+}
+
+void CefExtensionsAPIProvider::AddAPIFeatures(FeatureProvider* provider) {
+  AddCEFAPIFeatures(provider);
+}
+
+void CefExtensionsAPIProvider::AddManifestFeatures(
+    FeatureProvider* provider) {
+  AddCEFManifestFeatures(provider);
+}
+
+void CefExtensionsAPIProvider::AddPermissionFeatures(
+    FeatureProvider* provider) {
+  AddCEFPermissionFeatures(provider);
+}
+
+void CefExtensionsAPIProvider::AddBehaviorFeatures(
+    FeatureProvider* provider) {
+  // No CEF-specific behavior features.
+}
+
+void CefExtensionsAPIProvider::AddAPIJSONSources(
+    JSONFeatureProviderSource* json_source) {
+  // Extension API features specific to CEF. See
+  // libcef/common/extensions/api/README.txt for additional details.
+  json_source->LoadJSON(IDR_CEF_EXTENSION_API_FEATURES);
+}
+
+bool CefExtensionsAPIProvider::IsAPISchemaGenerated(const std::string& name) {
+  // Schema for CEF-only APIs.
+  // TODO(cef): Enable if/when CEF exposes its own Mojo APIs. See
+  // libcef/common/extensions/api/README.txt for details.
+  // if (api::cef::CefGeneratedSchemas::IsGenerated(name))
+  //   return true;
+
+  // Chrome APIs whitelisted by CEF.
+  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name))
+    return true;
+
+  return false;
+}
+
+base::StringPiece CefExtensionsAPIProvider::GetAPISchema(
+    const std::string& name) {
+  // Schema for CEF-only APIs.
+  // TODO(cef): Enable if/when CEF exposes its own Mojo APIs. See
+  // libcef/common/extensions/api/README.txt for details.
+  // if (api::cef::CefGeneratedSchemas::IsGenerated(name))
+  //   return api::cef::CefGeneratedSchemas::Get(name);
+
+  // Chrome APIs whitelisted by CEF.
+  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name))
+    return api::cef::ChromeGeneratedSchemas::Get(name);
+
+  return base::StringPiece();
+}
+
+void CefExtensionsAPIProvider::AddPermissionsProviders(
+    PermissionsInfo* permissions_info) {
+  permissions_info->AddProvider(chrome_api_permissions_,
+                                GetChromePermissionAliases());
+}
+
+void CefExtensionsAPIProvider::RegisterManifestHandlers() {
+  RegisterChromeManifestHandlers();
+}
+
+}  // namespace extensions

libcef/common/extensions/extensions_api_provider.h

@@ -0,0 +1,37 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CEF_LIBCEF_COMMON_EXTENSIONS_EXTENSIONS_API_PROVIDER_H_
+#define CEF_LIBCEF_COMMON_EXTENSIONS_EXTENSIONS_API_PROVIDER_H_
+
+#include "base/macros.h"
+#include "chrome/common/extensions/permissions/chrome_api_permissions.h"
+#include "extensions/common/extensions_api_provider.h"
+
+namespace extensions {
+
+class CefExtensionsAPIProvider : public ExtensionsAPIProvider {
+ public:
+  CefExtensionsAPIProvider();
+
+  // ExtensionsAPIProvider:
+  void AddAPIFeatures(FeatureProvider* provider) override;
+  void AddManifestFeatures(FeatureProvider* provider) override;
+  void AddPermissionFeatures(FeatureProvider* provider) override;
+  void AddBehaviorFeatures(FeatureProvider* provider) override;
+  void AddAPIJSONSources(JSONFeatureProviderSource* json_source) override;
+  bool IsAPISchemaGenerated(const std::string& name) override;
+  base::StringPiece GetAPISchema(const std::string& name) override;
+  void AddPermissionsProviders(PermissionsInfo* permissions_info) override;
+  void RegisterManifestHandlers() override;
+
+ private:
+  const ChromeAPIPermissions chrome_api_permissions_;
+
+  DISALLOW_COPY_AND_ASSIGN(CefExtensionsAPIProvider);
+};
+
+}  // namespace extensions
+
+#endif  // CEF_LIBCEF_COMMON_EXTENSIONS_EXTENSIONS_API_PROVIDER_H_

libcef/common/extensions/extensions_client.cc

@@ -8,34 +8,15 @@
 #include <utility>
 
 #include "libcef/common/cef_switches.h"
-#include "libcef/common/extensions/chrome_generated_schemas.h"
+#include "libcef/common/extensions/extensions_api_provider.h"
 
 #include "base/logging.h"
-#include "cef/grit/cef_resources.h"
-//#include "cef/libcef/common/extensions/api/generated_schemas.h"
-#include "cef/libcef/common/extensions/api/cef_api_features.h"
-#include "cef/libcef/common/extensions/api/cef_manifest_features.h"
-#include "cef/libcef/common/extensions/api/cef_permission_features.h"
-#include "chrome/common/extensions/chrome_aliases.h"
-#include "chrome/common/extensions/chrome_manifest_handlers.h"
-#include "chrome/grit/common_resources.h"
-#include "extensions/common/api/api_features.h"
-#include "extensions/common/api/behavior_features.h"
-#include "extensions/common/api/generated_schemas.h"
-#include "extensions/common/api/manifest_features.h"
-#include "extensions/common/api/permission_features.h"
-#include "extensions/common/common_manifest_handlers.h"
+#include "extensions/common/core_extensions_api_provider.h"
 #include "extensions/common/extension_urls.h"
-#include "extensions/common/extensions_aliases.h"
-#include "extensions/common/features/feature_provider.h"
-#include "extensions/common/features/json_feature_provider_source.h"
 #include "extensions/common/features/simple_feature.h"
-#include "extensions/common/manifest_handler.h"
 #include "extensions/common/permissions/permission_message_provider.h"
-#include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/permissions/permissions_provider.h"
 #include "extensions/common/url_pattern_set.h"
-#include "extensions/grit/extensions_resources.h"
 
 namespace extensions {
 
@@ -50,22 +31,14 @@ SimpleFeature* CreateFeature() {
 
 CefExtensionsClient::CefExtensionsClient()
     : webstore_base_url_(extension_urls::kChromeWebstoreBaseURL),
-      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {}
+      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {
+  AddAPIProvider(std::make_unique<CoreExtensionsAPIProvider>());
+  AddAPIProvider(std::make_unique<CefExtensionsAPIProvider>());
+}
 
 CefExtensionsClient::~CefExtensionsClient() {}
 
-void CefExtensionsClient::Initialize() {
-  RegisterCommonManifestHandlers();
-  RegisterChromeManifestHandlers();
-  ManifestHandler::FinalizeRegistration();
-  // TODO(jamescook): Do we need to whitelist any extensions?
-
-  // Set up permissions.
-  PermissionsInfo::GetInstance()->AddProvider(chrome_api_permissions_,
-                                              GetChromePermissionAliases());
-  PermissionsInfo::GetInstance()->AddProvider(extensions_api_permissions_,
-                                              GetExtensionsPermissionAliases());
-}
+void CefExtensionsClient::Initialize() {}
 
 void CefExtensionsClient::InitializeWebStoreUrls(
     base::CommandLine* command_line) {}
@@ -79,40 +52,6 @@ const std::string CefExtensionsClient::GetProductName() {
   return "cef";
 }
 
-std::unique_ptr<FeatureProvider> CefExtensionsClient::CreateFeatureProvider(
-    const std::string& name) const {
-  auto provider = std::make_unique<FeatureProvider>();
-  if (name == "api") {
-    AddCoreAPIFeatures(provider.get());
-    AddCEFAPIFeatures(provider.get());
-  } else if (name == "manifest") {
-    AddCoreManifestFeatures(provider.get());
-    AddCEFManifestFeatures(provider.get());
-  } else if (name == "permission") {
-    AddCorePermissionFeatures(provider.get());
-    AddCEFPermissionFeatures(provider.get());
-  } else if (name == "behavior") {
-    // Note: There are no CEF-specific behavior features.
-    AddCoreBehaviorFeatures(provider.get());
-  } else {
-    NOTREACHED();
-  }
-  return provider;
-}
-
-std::unique_ptr<JSONFeatureProviderSource>
-CefExtensionsClient::CreateAPIFeatureSource() const {
-  std::unique_ptr<JSONFeatureProviderSource> source(
-      new JSONFeatureProviderSource("api"));
-  source->LoadJSON(IDR_EXTENSION_API_FEATURES);
-
-  // Extension API features specific to CEF. See
-  // libcef/common/extensions/api/README.txt for additional details.
-  source->LoadJSON(IDR_CEF_EXTENSION_API_FEATURES);
-
-  return source;
-}
-
 void CefExtensionsClient::FilterHostPermissions(
     const URLPatternSet& hosts,
     URLPatternSet* new_hosts,
@@ -142,40 +81,6 @@ bool CefExtensionsClient::IsScriptableURL(const GURL& url,
   return true;
 }
 
-bool CefExtensionsClient::IsAPISchemaGenerated(const std::string& name) const {
-  // Schema for CEF-only APIs.
-  // TODO(cef): Enable if/when CEF exposes its own Mojo APIs. See
-  // libcef/common/extensions/api/README.txt for details.
-  // if (api::cef::CefGeneratedSchemas::IsGenerated(name))
-  //   return true;
-
-  // Chrome APIs whitelisted by CEF.
-  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name))
-    return true;
-
-  // Core extensions APIs.
-  if (api::GeneratedSchemas::IsGenerated(name))
-    return true;
-
-  return false;
-}
-
-base::StringPiece CefExtensionsClient::GetAPISchema(
-    const std::string& name) const {
-  // Schema for CEF-only APIs.
-  // TODO(cef): Enable if/when CEF exposes its own Mojo APIs. See
-  // libcef/common/extensions/api/README.txt for details.
-  // if (api::cef::CefGeneratedSchemas::IsGenerated(name))
-  //   return api::cef::CefGeneratedSchemas::Get(name);
-
-  // Chrome APIs whitelisted by CEF.
-  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name))
-    return api::cef::ChromeGeneratedSchemas::Get(name);
-
-  // Core extensions APIs.
-  return api::GeneratedSchemas::Get(name);
-}
-
 bool CefExtensionsClient::ShouldSuppressFatalErrors() const {
   return true;
 }

libcef/common/extensions/extensions_client.h

@@ -8,10 +8,8 @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "chrome/common/extensions/permissions/chrome_api_permissions.h"
 #include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
 #include "extensions/common/extensions_client.h"
-#include "extensions/common/permissions/extensions_api_permissions.h"
 #include "url/gurl.h"
 
 namespace extensions {
@@ -28,10 +26,6 @@ class CefExtensionsClient : public ExtensionsClient {
   const PermissionMessageProvider& GetPermissionMessageProvider()
       const override;
   const std::string GetProductName() override;
-  std::unique_ptr<FeatureProvider> CreateFeatureProvider(
-      const std::string& name) const override;
-  std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource()
-      const override;
   void FilterHostPermissions(const URLPatternSet& hosts,
                              URLPatternSet* new_hosts,
                              PermissionIDSet* permissions) const override;
@@ -41,8 +35,6 @@ class CefExtensionsClient : public ExtensionsClient {
       const Extension* extension,
       const APIPermissionSet& api_permissions) const override;
   bool IsScriptableURL(const GURL& url, std::string* error) const override;
-  bool IsAPISchemaGenerated(const std::string& name) const override;
-  base::StringPiece GetAPISchema(const std::string& name) const override;
   bool ShouldSuppressFatalErrors() const override;
   void RecordDidSuppressFatalError() override;
   const GURL& GetWebstoreBaseURL() const override;
@@ -50,8 +42,6 @@ class CefExtensionsClient : public ExtensionsClient {
   bool IsBlacklistUpdateURL(const GURL& url) const override;
 
  private:
-  const ChromeAPIPermissions chrome_api_permissions_;
-  const ExtensionsAPIPermissions extensions_api_permissions_;
   const ChromePermissionMessageProvider permission_message_provider_;
 
   ScriptingWhitelist scripting_whitelist_;