feat: preliminary support for //extensions (#17440)

shell/common/api/features.cc

@@ -41,6 +41,10 @@ bool IsPrintingEnabled() {
   return BUILDFLAG(ENABLE_PRINTING);
 }
 
+bool IsExtensionsEnabled() {
+  return BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS);
+}
+
 bool IsComponentBuild() {
 #if defined(COMPONENT_BUILD)
   return true;
@@ -64,6 +68,7 @@ void Initialize(v8::Local<v8::Object> exports,
   dict.SetMethod("isTtsEnabled", &IsTtsEnabled);
   dict.SetMethod("isPrintingEnabled", &IsPrintingEnabled);
   dict.SetMethod("isComponentBuild", &IsComponentBuild);
+  dict.SetMethod("isExtensionsEnabled", &IsExtensionsEnabled);
 }
 
 }  // namespace

shell/common/extensions/api/BUILD.gn

@@ -0,0 +1,35 @@
+# Copyright 2015 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.
+
+import("//extensions/buildflags/buildflags.gni")
+import("//tools/json_schema_compiler/json_features.gni")
+import("//tools/json_schema_compiler/json_schema_api.gni")
+
+assert(enable_extensions)
+
+################################################################################
+# Public Targets
+
+group("extensions_features") {
+  public_deps = [
+    ":manifest_features",
+
+    # TODO(devlin): It would be nicer to have this dependency hoisted up to
+    # //extensions/common (since that's where it's consumed), but there's some
+    # cycles to be resolved first.
+    "//extensions/common/api:extensions_features",
+  ]
+}
+
+################################################################################
+# Private Targets
+
+json_features("manifest_features") {
+  feature_type = "ManifestFeature"
+  method_name = "AddAtomManifestFeatures"
+  sources = [
+    "_manifest_features.json",
+  ]
+  visibility = [ ":extensions_features" ]
+}

shell/common/extensions/api/_manifest_features.json

@@ -0,0 +1,14 @@
+// Copyright (c) 2012 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.
+
+// This features file defines manifest keys implemented under src/chrome.
+// See chrome/common/extensions/api/_features.md to understand this file, as
+// well as feature.h, simple_feature.h, and feature_provider.h.
+
+{
+  "content_scripts": {
+    "channel": "stable",
+    "extension_types": ["extension", "legacy_packaged_app"]
+  }
+}

shell/common/extensions/atom_extensions_api_provider.cc

@@ -0,0 +1,67 @@
+// 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 "shell/common/extensions/atom_extensions_api_provider.h"
+
+#include <string>
+
+#include "electron/buildflags/buildflags.h"
+#include "extensions/common/features/json_feature_provider_source.h"
+
+#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
+#include "shell/common/extensions/api/manifest_features.h"
+#endif
+
+namespace electron {
+
+AtomExtensionsAPIProvider::AtomExtensionsAPIProvider() = default;
+AtomExtensionsAPIProvider::~AtomExtensionsAPIProvider() = default;
+
+// TODO(samuelmaddock): generate API features?
+
+void AtomExtensionsAPIProvider::AddAPIFeatures(
+    extensions::FeatureProvider* provider) {
+  // AddShellAPIFeatures(provider);
+}
+
+void AtomExtensionsAPIProvider::AddManifestFeatures(
+    extensions::FeatureProvider* provider) {
+#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
+  // TODO(samuelmaddock): why is the extensions namespace generated?
+  extensions::AddAtomManifestFeatures(provider);
+#endif
+}
+
+void AtomExtensionsAPIProvider::AddPermissionFeatures(
+    extensions::FeatureProvider* provider) {
+  // No shell-specific permission features.
+}
+
+void AtomExtensionsAPIProvider::AddBehaviorFeatures(
+    extensions::FeatureProvider* provider) {
+  // No shell-specific behavior features.
+}
+
+void AtomExtensionsAPIProvider::AddAPIJSONSources(
+    extensions::JSONFeatureProviderSource* json_source) {
+  // json_source->LoadJSON(IDR_SHELL_EXTENSION_API_FEATURES);
+}
+
+bool AtomExtensionsAPIProvider::IsAPISchemaGenerated(const std::string& name) {
+  // return shell::api::ShellGeneratedSchemas::IsGenerated(name);
+  return false;
+}
+
+base::StringPiece AtomExtensionsAPIProvider::GetAPISchema(
+    const std::string& name) {
+  // return shell::api::ShellGeneratedSchemas::Get(name);
+  return "";
+}
+
+void AtomExtensionsAPIProvider::RegisterPermissions(
+    extensions::PermissionsInfo* permissions_info) {}
+
+void AtomExtensionsAPIProvider::RegisterManifestHandlers() {}
+
+}  // namespace electron

shell/common/extensions/atom_extensions_api_provider.h

@@ -0,0 +1,39 @@
+// 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 SHELL_COMMON_EXTENSIONS_ATOM_EXTENSIONS_API_PROVIDER_H_
+#define SHELL_COMMON_EXTENSIONS_ATOM_EXTENSIONS_API_PROVIDER_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "extensions/common/extensions_api_provider.h"
+
+namespace electron {
+
+class AtomExtensionsAPIProvider : public extensions::ExtensionsAPIProvider {
+ public:
+  AtomExtensionsAPIProvider();
+  ~AtomExtensionsAPIProvider() override;
+
+  // ExtensionsAPIProvider:
+  void AddAPIFeatures(extensions::FeatureProvider* provider) override;
+  void AddManifestFeatures(extensions::FeatureProvider* provider) override;
+  void AddPermissionFeatures(extensions::FeatureProvider* provider) override;
+  void AddBehaviorFeatures(extensions::FeatureProvider* provider) override;
+  void AddAPIJSONSources(
+      extensions::JSONFeatureProviderSource* json_source) override;
+  bool IsAPISchemaGenerated(const std::string& name) override;
+  base::StringPiece GetAPISchema(const std::string& name) override;
+  void RegisterPermissions(
+      extensions::PermissionsInfo* permissions_info) override;
+  void RegisterManifestHandlers() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomExtensionsAPIProvider);
+};
+
+}  // namespace electron
+
+#endif  // SHELL_COMMON_EXTENSIONS_ATOM_EXTENSIONS_API_PROVIDER_H_

shell/common/extensions/atom_extensions_client.cc

@@ -0,0 +1,143 @@
+// Copyright 2014 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 "shell/common/extensions/atom_extensions_client.h"
+
+#include <memory>
+#include <string>
+
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "components/version_info/version_info.h"
+#include "content/public/common/user_agent.h"
+#include "extensions/common/core_extensions_api_provider.h"
+#include "extensions/common/extension_urls.h"
+#include "extensions/common/features/simple_feature.h"
+#include "extensions/common/permissions/permission_message_provider.h"
+#include "extensions/common/url_pattern_set.h"
+#include "shell/common/extensions/atom_extensions_api_provider.h"
+
+using extensions::ExtensionsClient;
+
+namespace electron {
+
+namespace {
+
+// TODO(jamescook): Refactor ChromePermissionsMessageProvider so we can share
+// code. For now, this implementation does nothing.
+class AtomPermissionMessageProvider
+    : public extensions::PermissionMessageProvider {
+ public:
+  AtomPermissionMessageProvider() {}
+  ~AtomPermissionMessageProvider() override {}
+
+  // PermissionMessageProvider implementation.
+  extensions::PermissionMessages GetPermissionMessages(
+      const extensions::PermissionIDSet& permissions) const override {
+    return extensions::PermissionMessages();
+  }
+
+  extensions::PermissionMessages GetPowerfulPermissionMessages(
+      const extensions::PermissionIDSet& permissions) const override {
+    return extensions::PermissionMessages();
+  }
+
+  bool IsPrivilegeIncrease(
+      const extensions::PermissionSet& granted_permissions,
+      const extensions::PermissionSet& requested_permissions,
+      extensions::Manifest::Type extension_type) const override {
+    // Ensure we implement this before shipping.
+    CHECK(false);
+    return false;
+  }
+
+  extensions::PermissionIDSet GetAllPermissionIDs(
+      const extensions::PermissionSet& permissions,
+      extensions::Manifest::Type extension_type) const override {
+    return extensions::PermissionIDSet();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomPermissionMessageProvider);
+};
+
+base::LazyInstance<AtomPermissionMessageProvider>::DestructorAtExit
+    g_permission_message_provider = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+AtomExtensionsClient::AtomExtensionsClient()
+    : webstore_base_url_(extension_urls::kChromeWebstoreBaseURL),
+      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {
+  AddAPIProvider(std::make_unique<extensions::CoreExtensionsAPIProvider>());
+  AddAPIProvider(std::make_unique<AtomExtensionsAPIProvider>());
+}
+
+AtomExtensionsClient::~AtomExtensionsClient() {}
+
+void AtomExtensionsClient::Initialize() {
+  // TODO(jamescook): Do we need to whitelist any extensions?
+}
+
+void AtomExtensionsClient::InitializeWebStoreUrls(
+    base::CommandLine* command_line) {}
+
+const extensions::PermissionMessageProvider&
+AtomExtensionsClient::GetPermissionMessageProvider() const {
+  NOTIMPLEMENTED();
+  return g_permission_message_provider.Get();
+}
+
+const std::string AtomExtensionsClient::GetProductName() {
+  // TODO(samuelmaddock):
+  return "app_shell";
+}
+
+void AtomExtensionsClient::FilterHostPermissions(
+    const extensions::URLPatternSet& hosts,
+    extensions::URLPatternSet* new_hosts,
+    extensions::PermissionIDSet* permissions) const {
+  NOTIMPLEMENTED();
+}
+
+void AtomExtensionsClient::SetScriptingWhitelist(
+    const ExtensionsClient::ScriptingWhitelist& whitelist) {
+  scripting_whitelist_ = whitelist;
+}
+
+const ExtensionsClient::ScriptingWhitelist&
+AtomExtensionsClient::GetScriptingWhitelist() const {
+  // TODO(jamescook): Real whitelist.
+  return scripting_whitelist_;
+}
+
+extensions::URLPatternSet AtomExtensionsClient::GetPermittedChromeSchemeHosts(
+    const extensions::Extension* extension,
+    const extensions::APIPermissionSet& api_permissions) const {
+  NOTIMPLEMENTED();
+  return extensions::URLPatternSet();
+}
+
+bool AtomExtensionsClient::IsScriptableURL(const GURL& url,
+                                           std::string* error) const {
+  // No restrictions on URLs.
+  return true;
+}
+
+const GURL& AtomExtensionsClient::GetWebstoreBaseURL() const {
+  return webstore_base_url_;
+}
+
+const GURL& AtomExtensionsClient::GetWebstoreUpdateURL() const {
+  return webstore_update_url_;
+}
+
+bool AtomExtensionsClient::IsBlacklistUpdateURL(const GURL& url) const {
+  // TODO(rockot): Maybe we want to do something else here. For now we accept
+  // any URL as a blacklist URL because we don't really care.
+  return true;
+}
+
+}  // namespace electron

shell/common/extensions/atom_extensions_client.h

@@ -0,0 +1,65 @@
+// Copyright 2014 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 SHELL_COMMON_EXTENSIONS_ATOM_EXTENSIONS_CLIENT_H_
+#define SHELL_COMMON_EXTENSIONS_ATOM_EXTENSIONS_CLIENT_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "extensions/common/extensions_client.h"
+#include "url/gurl.h"
+
+namespace extensions {
+class APIPermissionSet;
+class Extension;
+class PermissionMessageProvider;
+class PermissionIDSet;
+class ScriptingWhitelist;
+class URLPatternSet;
+}  // namespace extensions
+
+namespace electron {
+
+// The app_shell implementation of ExtensionsClient.
+class AtomExtensionsClient : public extensions::ExtensionsClient {
+ public:
+  typedef extensions::ExtensionsClient::ScriptingWhitelist ScriptingWhitelist;
+
+  AtomExtensionsClient();
+  ~AtomExtensionsClient() override;
+
+  // ExtensionsClient overrides:
+  void Initialize() override;
+  void InitializeWebStoreUrls(base::CommandLine* command_line) override;
+  const extensions::PermissionMessageProvider& GetPermissionMessageProvider()
+      const override;
+  const std::string GetProductName() override;
+  void FilterHostPermissions(
+      const extensions::URLPatternSet& hosts,
+      extensions::URLPatternSet* new_hosts,
+      extensions::PermissionIDSet* permissions) const override;
+  void SetScriptingWhitelist(const ScriptingWhitelist& whitelist) override;
+  const ScriptingWhitelist& GetScriptingWhitelist() const override;
+  extensions::URLPatternSet GetPermittedChromeSchemeHosts(
+      const extensions::Extension* extension,
+      const extensions::APIPermissionSet& api_permissions) const override;
+  bool IsScriptableURL(const GURL& url, std::string* error) const override;
+  const GURL& GetWebstoreBaseURL() const override;
+  const GURL& GetWebstoreUpdateURL() const override;
+  bool IsBlacklistUpdateURL(const GURL& url) const override;
+
+ private:
+  ScriptingWhitelist scripting_whitelist_;
+
+  const GURL webstore_base_url_;
+  const GURL webstore_update_url_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomExtensionsClient);
+};
+
+}  // namespace electron
+
+#endif  // SHELL_COMMON_EXTENSIONS_ATOM_EXTENSIONS_CLIENT_H_