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

This commit is contained in:
Samuel Maddock 2019-07-24 19:01:08 -04:00 committed by Jeremy Apthorp
parent bd526f97a5
commit 95977291f7
54 changed files with 2483 additions and 36 deletions

View file

@ -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" ]
}

View file

@ -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"]
}
}

View file

@ -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

View file

@ -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_

View file

@ -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

View file

@ -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_