mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

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

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

2
shell/renderer/atom_renderer_client.cc
View file

@ -50,6 +50,7 @@ void AtomRendererClient::RenderFrameCreated(
void AtomRendererClient::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentStart(render_frame);
// Inform the document start pharse.
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
node::Environment* env = GetEnvironment(render_frame);
@ -59,6 +60,7 @@ void AtomRendererClient::RunScriptsAtDocumentStart(
void AtomRendererClient::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentEnd(render_frame);
// Inform the document end pharse.
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
node::Environment* env = GetEnvironment(render_frame);

2
shell/renderer/atom_sandboxed_renderer_client.cc
View file

@ -165,6 +165,7 @@ void AtomSandboxedRendererClient::RenderViewCreated(
void AtomSandboxedRendererClient::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentStart(render_frame);
if (injected_frames_.find(render_frame) == injected_frames_.end())
return;
@ -180,6 +181,7 @@ void AtomSandboxedRendererClient::RunScriptsAtDocumentStart(
void AtomSandboxedRendererClient::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentEnd(render_frame);
if (injected_frames_.find(render_frame) == injected_frames_.end())
return;

65
shell/renderer/extensions/atom_extensions_renderer_client.cc Normal file
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.
#include "shell/renderer/extensions/atom_extensions_renderer_client.h"
#include "content/public/renderer/render_thread.h"
#include "extensions/renderer/dispatcher.h"
#include "extensions/renderer/dispatcher_delegate.h"
namespace electron {
AtomExtensionsRendererClient::AtomExtensionsRendererClient()
: dispatcher_(std::make_unique<extensions::Dispatcher>(
std::make_unique<extensions::DispatcherDelegate>())) {
dispatcher_->OnRenderThreadStarted(content::RenderThread::Get());
}
AtomExtensionsRendererClient::~AtomExtensionsRendererClient() {}
bool AtomExtensionsRendererClient::IsIncognitoProcess() const {
// app_shell doesn't support off-the-record contexts.
return false;
}
int AtomExtensionsRendererClient::GetLowestIsolatedWorldId() const {
// app_shell doesn't need to reserve world IDs for anything other than
// extensions, so we always return 1. Note that 0 is reserved for the global
// world.
// TODO(samuelmaddock): skip electron worlds
return 10;
}
extensions::Dispatcher* AtomExtensionsRendererClient::GetDispatcher() {
return dispatcher_.get();
}
bool AtomExtensionsRendererClient::ExtensionAPIEnabledForServiceWorkerScript(
const GURL& scope,
const GURL& script_url) const {
// TODO(nornagon): adapt logic from chrome's version
return true;
}
bool AtomExtensionsRendererClient::AllowPopup() {
// TODO(samuelmaddock):
return false;
}
void AtomExtensionsRendererClient::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
dispatcher_->RunScriptsAtDocumentStart(render_frame);
}
void AtomExtensionsRendererClient::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
dispatcher_->RunScriptsAtDocumentEnd(render_frame);
}
void AtomExtensionsRendererClient::RunScriptsAtDocumentIdle(
content::RenderFrame* render_frame) {
dispatcher_->RunScriptsAtDocumentIdle(render_frame);
}
} // namespace electron

51
shell/renderer/extensions/atom_extensions_renderer_client.h Normal file
View file

@ -0,0 +1,51 @@
// Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_EXTENSIONS_ATOM_EXTENSIONS_RENDERER_CLIENT_H_
#define SHELL_RENDERER_EXTENSIONS_ATOM_EXTENSIONS_RENDERER_CLIENT_H_
#include <memory>
#include "base/macros.h"
#include "extensions/renderer/extensions_renderer_client.h"
namespace content {
class RenderFrame;
}
namespace extensions {
class Dispatcher;
}
namespace electron {
class AtomExtensionsRendererClient
: public extensions::ExtensionsRendererClient {
public:
AtomExtensionsRendererClient();
~AtomExtensionsRendererClient() override;
// ExtensionsRendererClient implementation.
bool IsIncognitoProcess() const override;
int GetLowestIsolatedWorldId() const override;
extensions::Dispatcher* GetDispatcher() override;
bool ExtensionAPIEnabledForServiceWorkerScript(
const GURL& scope,
const GURL& script_url) const override;
bool AllowPopup();
void RunScriptsAtDocumentStart(content::RenderFrame* render_frame);
void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame);
void RunScriptsAtDocumentIdle(content::RenderFrame* render_frame);
private:
std::unique_ptr<extensions::Dispatcher> dispatcher_;
DISALLOW_COPY_AND_ASSIGN(AtomExtensionsRendererClient);
};
} // namespace electron
#endif // SHELL_RENDERER_EXTENSIONS_ATOM_EXTENSIONS_RENDERER_CLIENT_H_

59
shell/renderer/renderer_client_base.cc
View file

@ -15,6 +15,7 @@
#include "content/public/common/content_constants.h"
#include "content/public/common/content_switches.h"
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_thread.h"
#include "content/public/renderer/render_view.h"
#include "electron/buildflags/buildflags.h"
#include "native_mate/dictionary.h"
@ -62,6 +63,17 @@
#include "shell/renderer/printing/print_render_frame_helper_delegate.h"
#endif // BUILDFLAG(ENABLE_PRINTING)
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
#include "extensions/common/extensions_client.h"
#include "extensions/renderer/dispatcher.h"
#include "extensions/renderer/extension_frame_helper.h"
#include "extensions/renderer/guest_view/extensions_guest_view_container.h"
#include "extensions/renderer/guest_view/extensions_guest_view_container_dispatcher.h"
#include "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.h"
#include "shell/common/extensions/atom_extensions_client.h"
#include "shell/renderer/extensions/atom_extensions_renderer_client.h"
#endif // BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
namespace electron {
namespace {
@ -128,6 +140,18 @@ void RendererClientBase::RenderThreadStarted() {
}
#endif
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
auto* thread = content::RenderThread::Get();
extensions_client_.reset(CreateExtensionsClient());
extensions::ExtensionsClient::Set(extensions_client_.get());
extensions_renderer_client_.reset(new AtomExtensionsRendererClient);
extensions::ExtensionsRendererClient::Set(extensions_renderer_client_.get());
thread->AddObserver(extensions_renderer_client_->GetDispatcher());
#endif
blink::WebCustomElement::AddEmbedderCustomElementName("webview");
blink::WebCustomElement::AddEmbedderCustomElementName("browserplugin");
@ -236,6 +260,14 @@ void RendererClientBase::RenderFrameCreated(
}
}
}
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
auto* dispatcher = extensions_renderer_client_->GetDispatcher();
// ExtensionFrameHelper destroys itself when the RenderFrame is destroyed.
new extensions::ExtensionFrameHelper(render_frame, dispatcher);
dispatcher->OnRenderFrameCreated(render_frame);
#endif
}
void RendererClientBase::DidClearWindowObject(
@ -291,6 +323,27 @@ void RendererClientBase::DidSetUserAgent(const std::string& user_agent) {
#endif
}
void RendererClientBase::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
extensions_renderer_client_.get()->RunScriptsAtDocumentStart(render_frame);
#endif
}
void RendererClientBase::RunScriptsAtDocumentIdle(
content::RenderFrame* render_frame) {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
extensions_renderer_client_.get()->RunScriptsAtDocumentIdle(render_frame);
#endif
}
void RendererClientBase::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
extensions_renderer_client_.get()->RunScriptsAtDocumentEnd(render_frame);
#endif
}
v8::Local<v8::Context> RendererClientBase::GetContext(
blink::WebLocalFrame* frame,
v8::Isolate* isolate) const {
@ -310,6 +363,12 @@ v8::Local<v8::Value> RendererClientBase::RunScript(
return script->Run(context).ToLocalChecked();
}
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
extensions::ExtensionsClient* RendererClientBase::CreateExtensionsClient() {
return new AtomExtensionsClient;
}
#endif
bool RendererClientBase::IsWebViewFrame(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame) const {

26
shell/renderer/renderer_client_base.h
View file

@ -10,6 +10,7 @@
#include <vector>
#include "content/public/renderer/content_renderer_client.h"
#include "electron/buildflags/buildflags.h"
#include "third_party/blink/public/web/web_local_frame.h"
// In SHARED_INTERMEDIATE_DIR.
#include "widevine_cdm_version.h" // NOLINT(build/include)
@ -18,8 +19,18 @@
#include "chrome/renderer/media/chrome_key_systems_provider.h" // nogncheck
#endif
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
namespace extensions {
class ExtensionsClient;
}
#endif
namespace electron {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
class AtomExtensionsRendererClient;
#endif
class RendererClientBase : public content::ContentRendererClient {
public:
RendererClientBase();
@ -67,7 +78,22 @@ class RendererClientBase : public content::ContentRendererClient {
bool IsKeySystemsUpdateNeeded() override;
void DidSetUserAgent(const std::string& user_agent) override;
void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override;
void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) override;
void RunScriptsAtDocumentIdle(content::RenderFrame* render_frame) override;
protected:
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
// app_shell embedders may need custom extensions client interfaces.
// This class takes ownership of the returned object.
virtual extensions::ExtensionsClient* CreateExtensionsClient();
#endif
private:
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
std::unique_ptr<extensions::ExtensionsClient> extensions_client_;
std::unique_ptr<AtomExtensionsRendererClient> extensions_renderer_client_;
#endif
#if defined(WIDEVINE_CDM_AVAILABLE)
ChromeKeySystemsProvider key_systems_provider_;
#endif