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

chore: rename atom -> electron (#21986)

Browse source
This commit is contained in:
Jeremy Apthorp 2020-02-04 12:19:40 -08:00 • committed by GitHub
parent f14fc4b041
commit d9321f4df7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
287 changed files with 1771 additions and 1708 deletions
Download patch file Download diff file Expand all files Collapse all files

2
shell/renderer/api/context_bridge/render_frame_context_bridge_store.h
View file

@ -10,7 +10,7 @@
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_frame_observer.h"
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include "third_party/blink/public/web/web_local_frame.h"
namespace electron {

4
shell/renderer/api/atom_api_context_bridge.cc → shell/renderer/api/electron_api_context_bridge.cc
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/renderer/api/atom_api_context_bridge.h"
#include "shell/renderer/api/electron_api_context_bridge.h"
#include <map>
#include <set>
@ -21,7 +21,7 @@
#include "shell/common/gin_helper/promise.h"
#include "shell/common/node_includes.h"
#include "shell/renderer/api/context_bridge/render_frame_context_bridge_store.h"
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include "third_party/blink/public/web/web_local_frame.h"
namespace electron {

6
shell/renderer/api/atom_api_context_bridge.h → shell/renderer/api/electron_api_context_bridge.h
View file

@ -2,8 +2,8 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_API_ATOM_API_CONTEXT_BRIDGE_H_
#define SHELL_RENDERER_API_ATOM_API_CONTEXT_BRIDGE_H_
#ifndef SHELL_RENDERER_API_ELECTRON_API_CONTEXT_BRIDGE_H_
#define SHELL_RENDERER_API_ELECTRON_API_CONTEXT_BRIDGE_H_
#include "v8/include/v8.h"
@ -35,4 +35,4 @@ v8::MaybeLocal<v8::Object> CreateProxyForAPI(
} // namespace electron
#endif // SHELL_RENDERER_API_ATOM_API_CONTEXT_BRIDGE_H_
#endif // SHELL_RENDERER_API_ELECTRON_API_CONTEXT_BRIDGE_H_

0
shell/renderer/api/atom_api_renderer_ipc.cc → shell/renderer/api/electron_api_renderer_ipc.cc
View file

2
shell/renderer/api/atom_api_spell_check_client.cc → shell/renderer/api/electron_api_spell_check_client.cc
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/renderer/api/atom_api_spell_check_client.h"
#include "shell/renderer/api/electron_api_spell_check_client.h"
#include <map>
#include <memory>

6
shell/renderer/api/atom_api_spell_check_client.h → shell/renderer/api/electron_api_spell_check_client.h
View file

@ -2,8 +2,8 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
#define SHELL_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
#ifndef SHELL_RENDERER_API_ELECTRON_API_SPELL_CHECK_CLIENT_H_
#define SHELL_RENDERER_API_ELECTRON_API_SPELL_CHECK_CLIENT_H_
#include <memory>
#include <set>
@ -111,4 +111,4 @@ class SpellCheckClient : public blink::WebSpellCheckPanelHostClient,
} // namespace electron
#endif // SHELL_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
#endif // SHELL_RENDERER_API_ELECTRON_API_SPELL_CHECK_CLIENT_H_

2
shell/renderer/api/atom_api_web_frame.cc → shell/renderer/api/electron_api_web_frame.cc
View file

@ -18,7 +18,7 @@
#include "shell/common/gin_helper/dictionary.h"
#include "shell/common/gin_helper/promise.h"
#include "shell/common/node_includes.h"
#include "shell/renderer/api/atom_api_spell_check_client.h"
#include "shell/renderer/api/electron_api_spell_check_client.h"
#include "third_party/blink/public/common/page/page_zoom.h"
#include "third_party/blink/public/common/web_cache/web_cache_resource_type_stats.h"
#include "third_party/blink/public/platform/web_cache.h"

4
shell/renderer/electron_api_service_impl.cc
View file

@ -12,13 +12,13 @@
#include "base/macros.h"
#include "base/threading/thread_restrictions.h"
#include "mojo/public/cpp/system/platform_handle.h"
#include "shell/common/atom_constants.h"
#include "shell/common/electron_constants.h"
#include "shell/common/gin_converters/blink_converter.h"
#include "shell/common/gin_converters/value_converter.h"
#include "shell/common/heap_snapshot.h"
#include "shell/common/node_includes.h"
#include "shell/common/options_switches.h"
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include "shell/renderer/renderer_client_base.h"
#include "third_party/blink/public/web/blink.h"
#include "third_party/blink/public/web/web_local_frame.h"

2
shell/renderer/atom_autofill_agent.cc → shell/renderer/electron_autofill_agent.cc
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/renderer/atom_autofill_agent.h"
#include "shell/renderer/electron_autofill_agent.h"
#include <utility>
#include <vector>

6
shell/renderer/atom_autofill_agent.h → shell/renderer/electron_autofill_agent.h
View file

@ -2,8 +2,8 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_ATOM_AUTOFILL_AGENT_H_
#define SHELL_RENDERER_ATOM_AUTOFILL_AGENT_H_
#ifndef SHELL_RENDERER_ELECTRON_AUTOFILL_AGENT_H_
#define SHELL_RENDERER_ELECTRON_AUTOFILL_AGENT_H_
#include <vector>
@ -91,4 +91,4 @@ class AutofillAgent : public content::RenderFrameObserver,
} // namespace electron
#endif // SHELL_RENDERER_ATOM_AUTOFILL_AGENT_H_
#endif // SHELL_RENDERER_ELECTRON_AUTOFILL_AGENT_H_

22
shell/renderer/atom_render_frame_observer.cc → shell/renderer/electron_render_frame_observer.cc
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include <string>
#include <utility>
@ -43,7 +43,7 @@ scoped_refptr<base::RefCountedMemory> NetResourceProvider(int key) {
} // namespace
AtomRenderFrameObserver::AtomRenderFrameObserver(
ElectronRenderFrameObserver::ElectronRenderFrameObserver(
content::RenderFrame* frame,
RendererClientBase* renderer_client)
: content::RenderFrameObserver(frame),
@ -53,11 +53,11 @@ AtomRenderFrameObserver::AtomRenderFrameObserver(
net::NetModule::SetResourceProvider(NetResourceProvider);
}
void AtomRenderFrameObserver::DidClearWindowObject() {
void ElectronRenderFrameObserver::DidClearWindowObject() {
renderer_client_->DidClearWindowObject(render_frame_);
}
void AtomRenderFrameObserver::DidCreateScriptContext(
void ElectronRenderFrameObserver::DidCreateScriptContext(
v8::Handle<v8::Context> context,
int world_id) {
if (ShouldNotifyClient(world_id))
@ -98,7 +98,7 @@ void AtomRenderFrameObserver::DidCreateScriptContext(
#endif
}
void AtomRenderFrameObserver::DraggableRegionsChanged() {
void ElectronRenderFrameObserver::DraggableRegionsChanged() {
blink::WebVector<blink::WebDraggableRegion> webregions =
render_frame_->GetWebFrame()->GetDocument().DraggableRegions();
std::vector<mojom::DraggableRegionPtr> regions;
@ -116,18 +116,18 @@ void AtomRenderFrameObserver::DraggableRegionsChanged() {
browser_ptr->UpdateDraggableRegions(std::move(regions));
}
void AtomRenderFrameObserver::WillReleaseScriptContext(
void ElectronRenderFrameObserver::WillReleaseScriptContext(
v8::Local<v8::Context> context,
int world_id) {
if (ShouldNotifyClient(world_id))
renderer_client_->WillReleaseScriptContext(context, render_frame_);
}
void AtomRenderFrameObserver::OnDestruct() {
void ElectronRenderFrameObserver::OnDestruct() {
delete this;
}
void AtomRenderFrameObserver::CreateIsolatedWorldContext() {
void ElectronRenderFrameObserver::CreateIsolatedWorldContext() {
auto* frame = render_frame_->GetWebFrame();
blink::WebIsolatedWorldInfo info;
// This maps to the name shown in the context combo box in the Console tab
@ -143,15 +143,15 @@ void AtomRenderFrameObserver::CreateIsolatedWorldContext() {
frame->ExecuteScriptInIsolatedWorld(World::ISOLATED_WORLD, source);
}
bool AtomRenderFrameObserver::IsMainWorld(int world_id) {
bool ElectronRenderFrameObserver::IsMainWorld(int world_id) {
return world_id == World::MAIN_WORLD;
}
bool AtomRenderFrameObserver::IsIsolatedWorld(int world_id) {
bool ElectronRenderFrameObserver::IsIsolatedWorld(int world_id) {
return world_id == World::ISOLATED_WORLD;
}
bool AtomRenderFrameObserver::ShouldNotifyClient(int world_id) {
bool ElectronRenderFrameObserver::ShouldNotifyClient(int world_id) {
bool allow_node_in_sub_frames =
base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kNodeIntegrationInSubFrames);

14
shell/renderer/atom_render_frame_observer.h → shell/renderer/electron_render_frame_observer.h
View file

@ -2,8 +2,8 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_ATOM_RENDER_FRAME_OBSERVER_H_
#define SHELL_RENDERER_ATOM_RENDER_FRAME_OBSERVER_H_
#ifndef SHELL_RENDERER_ELECTRON_RENDER_FRAME_OBSERVER_H_
#define SHELL_RENDERER_ELECTRON_RENDER_FRAME_OBSERVER_H_
#include <string>
@ -38,10 +38,10 @@ enum World {
};
// Helper class to forward the messages to the client.
class AtomRenderFrameObserver : public content::RenderFrameObserver {
class ElectronRenderFrameObserver : public content::RenderFrameObserver {
public:
AtomRenderFrameObserver(content::RenderFrame* frame,
RendererClientBase* renderer_client);
ElectronRenderFrameObserver(content::RenderFrame* frame,
RendererClientBase* renderer_client);
// content::RenderFrameObserver:
void DidClearWindowObject() override;
@ -63,9 +63,9 @@ class AtomRenderFrameObserver : public content::RenderFrameObserver {
content::RenderFrame* render_frame_;
RendererClientBase* renderer_client_;
DISALLOW_COPY_AND_ASSIGN(AtomRenderFrameObserver);
DISALLOW_COPY_AND_ASSIGN(ElectronRenderFrameObserver);
};
} // namespace electron
#endif // SHELL_RENDERER_ATOM_RENDER_FRAME_OBSERVER_H_
#endif // SHELL_RENDERER_ELECTRON_RENDER_FRAME_OBSERVER_H_

40
shell/renderer/atom_renderer_client.cc → shell/renderer/electron_renderer_client.cc
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/renderer/atom_renderer_client.h"
#include "shell/renderer/electron_renderer_client.h"
#include <string>
#include <vector>
@ -18,7 +18,7 @@
#include "shell/common/node_includes.h"
#include "shell/common/node_util.h"
#include "shell/common/options_switches.h"
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include "shell/renderer/web_worker_observer.h"
#include "third_party/blink/public/web/web_document.h"
#include "third_party/blink/public/web/web_local_frame.h"
@ -34,22 +34,22 @@ bool IsDevToolsExtension(content::RenderFrame* render_frame) {
} // namespace
AtomRendererClient::AtomRendererClient()
ElectronRendererClient::ElectronRendererClient()
: node_bindings_(
NodeBindings::Create(NodeBindings::BrowserEnvironment::RENDERER)),
electron_bindings_(new ElectronBindings(uv_default_loop())) {}
AtomRendererClient::~AtomRendererClient() {
ElectronRendererClient::~ElectronRendererClient() {
asar::ClearArchives();
}
void AtomRendererClient::RenderFrameCreated(
void ElectronRendererClient::RenderFrameCreated(
content::RenderFrame* render_frame) {
new AtomRenderFrameObserver(render_frame, this);
new ElectronRenderFrameObserver(render_frame, this);
RendererClientBase::RenderFrameCreated(render_frame);
}
void AtomRendererClient::RunScriptsAtDocumentStart(
void ElectronRendererClient::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentStart(render_frame);
// Inform the document start pharse.
@ -60,7 +60,7 @@ void AtomRendererClient::RunScriptsAtDocumentStart(
"document-start");
}
void AtomRendererClient::RunScriptsAtDocumentEnd(
void ElectronRendererClient::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentEnd(render_frame);
// Inform the document end pharse.
@ -71,7 +71,7 @@ void AtomRendererClient::RunScriptsAtDocumentEnd(
"document-end");
}
void AtomRendererClient::DidCreateScriptContext(
void ElectronRendererClient::DidCreateScriptContext(
v8::Handle<v8::Context> renderer_context,
content::RenderFrame* render_frame) {
RendererClientBase::DidCreateScriptContext(renderer_context, render_frame);
@ -153,7 +153,7 @@ void AtomRendererClient::DidCreateScriptContext(
}
}
void AtomRendererClient::WillReleaseScriptContext(
void ElectronRendererClient::WillReleaseScriptContext(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame) {
if (injected_frames_.erase(render_frame) == 0)
@ -187,11 +187,11 @@ void AtomRendererClient::WillReleaseScriptContext(
electron_bindings_->EnvironmentDestroyed(env);
}
bool AtomRendererClient::ShouldFork(blink::WebLocalFrame* frame,
const GURL& url,
const std::string& http_method,
bool is_initial_navigation,
bool is_server_redirect) {
bool ElectronRendererClient::ShouldFork(blink::WebLocalFrame* frame,
const GURL& url,
const std::string& http_method,
bool is_initial_navigation,
bool is_server_redirect) {
// Handle all the navigations and reloads in browser.
// FIXME We only support GET here because http method will be ignored when
// the OpenURLFromTab is triggered, which means form posting would not work,
@ -199,7 +199,7 @@ bool AtomRendererClient::ShouldFork(blink::WebLocalFrame* frame,
return http_method == "GET";
}
void AtomRendererClient::DidInitializeWorkerContextOnWorkerThread(
void ElectronRendererClient::DidInitializeWorkerContextOnWorkerThread(
v8::Local<v8::Context> context) {
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kNodeIntegrationInWorker)) {
@ -207,7 +207,7 @@ void AtomRendererClient::DidInitializeWorkerContextOnWorkerThread(
}
}
void AtomRendererClient::WillDestroyWorkerContextOnWorkerThread(
void ElectronRendererClient::WillDestroyWorkerContextOnWorkerThread(
v8::Local<v8::Context> context) {
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kNodeIntegrationInWorker)) {
@ -215,7 +215,7 @@ void AtomRendererClient::WillDestroyWorkerContextOnWorkerThread(
}
}
void AtomRendererClient::SetupMainWorldOverrides(
void ElectronRendererClient::SetupMainWorldOverrides(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame) {
// Setup window overrides in the main world context
@ -237,7 +237,7 @@ void AtomRendererClient::SetupMainWorldOverrides(
&isolated_bundle_params, &isolated_bundle_args, nullptr);
}
void AtomRendererClient::SetupExtensionWorldOverrides(
void ElectronRendererClient::SetupExtensionWorldOverrides(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame,
int world_id) {
@ -265,7 +265,7 @@ void AtomRendererClient::SetupExtensionWorldOverrides(
#endif
}
node::Environment* AtomRendererClient::GetEnvironment(
node::Environment* ElectronRendererClient::GetEnvironment(
content::RenderFrame* render_frame) const {
if (injected_frames_.find(render_frame) == injected_frames_.end())
return nullptr;

14
shell/renderer/atom_renderer_client.h → shell/renderer/electron_renderer_client.h
View file

@ -2,8 +2,8 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_ATOM_RENDERER_CLIENT_H_
#define SHELL_RENDERER_ATOM_RENDERER_CLIENT_H_
#ifndef SHELL_RENDERER_ELECTRON_RENDERER_CLIENT_H_
#define SHELL_RENDERER_ELECTRON_RENDERER_CLIENT_H_
#include <memory>
#include <set>
@ -21,10 +21,10 @@ namespace electron {
class ElectronBindings;
class NodeBindings;
class AtomRendererClient : public RendererClientBase {
class ElectronRendererClient : public RendererClientBase {
public:
AtomRendererClient();
~AtomRendererClient() override;
ElectronRendererClient();
~ElectronRendererClient() override;
// electron::RendererClientBase:
void DidCreateScriptContext(v8::Handle<v8::Context> context,
@ -70,9 +70,9 @@ class AtomRendererClient : public RendererClientBase {
// assertion, so we have to keep a book of injected web frames.
std::set<content::RenderFrame*> injected_frames_;
DISALLOW_COPY_AND_ASSIGN(AtomRendererClient);
DISALLOW_COPY_AND_ASSIGN(ElectronRendererClient);
};
} // namespace electron
#endif // SHELL_RENDERER_ATOM_RENDERER_CLIENT_H_
#endif // SHELL_RENDERER_ELECTRON_RENDERER_CLIENT_H_

28
shell/renderer/atom_sandboxed_renderer_client.cc → shell/renderer/electron_sandboxed_renderer_client.cc
View file

@ -2,7 +2,7 @@
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/renderer/atom_sandboxed_renderer_client.h"
#include "shell/renderer/electron_sandboxed_renderer_client.h"
#include "base/base_paths.h"
#include "base/command_line.h"
@ -18,7 +18,7 @@
#include "shell/common/node_includes.h"
#include "shell/common/node_util.h"
#include "shell/common/options_switches.h"
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include "third_party/blink/public/web/blink.h"
#include "third_party/blink/public/web/web_document.h"
#include "third_party/electron_node/src/node_binding.h"
@ -114,15 +114,15 @@ void InvokeHiddenCallback(v8::Handle<v8::Context> context,
} // namespace
AtomSandboxedRendererClient::AtomSandboxedRendererClient() {
ElectronSandboxedRendererClient::ElectronSandboxedRendererClient() {
// Explicitly register electron's builtin modules.
NodeBindings::RegisterBuiltinModules();
metrics_ = base::ProcessMetrics::CreateCurrentProcessMetrics();
}
AtomSandboxedRendererClient::~AtomSandboxedRendererClient() = default;
ElectronSandboxedRendererClient::~ElectronSandboxedRendererClient() = default;
void AtomSandboxedRendererClient::InitializeBindings(
void ElectronSandboxedRendererClient::InitializeBindings(
v8::Local<v8::Object> binding,
v8::Local<v8::Context> context,
bool is_main_frame) {
@ -143,18 +143,18 @@ void AtomSandboxedRendererClient::InitializeBindings(
process.SetReadOnly("isMainFrame", is_main_frame);
}
void AtomSandboxedRendererClient::RenderFrameCreated(
void ElectronSandboxedRendererClient::RenderFrameCreated(
content::RenderFrame* render_frame) {
new AtomRenderFrameObserver(render_frame, this);
new ElectronRenderFrameObserver(render_frame, this);
RendererClientBase::RenderFrameCreated(render_frame);
}
void AtomSandboxedRendererClient::RenderViewCreated(
void ElectronSandboxedRendererClient::RenderViewCreated(
content::RenderView* render_view) {
RendererClientBase::RenderViewCreated(render_view);
}
void AtomSandboxedRendererClient::RunScriptsAtDocumentStart(
void ElectronSandboxedRendererClient::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentStart(render_frame);
if (injected_frames_.find(render_frame) == injected_frames_.end())
@ -170,7 +170,7 @@ void AtomSandboxedRendererClient::RunScriptsAtDocumentStart(
InvokeHiddenCallback(context, kLifecycleKey, "onDocumentStart");
}
void AtomSandboxedRendererClient::RunScriptsAtDocumentEnd(
void ElectronSandboxedRendererClient::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
RendererClientBase::RunScriptsAtDocumentEnd(render_frame);
if (injected_frames_.find(render_frame) == injected_frames_.end())
@ -186,7 +186,7 @@ void AtomSandboxedRendererClient::RunScriptsAtDocumentEnd(
InvokeHiddenCallback(context, kLifecycleKey, "onDocumentEnd");
}
void AtomSandboxedRendererClient::DidCreateScriptContext(
void ElectronSandboxedRendererClient::DidCreateScriptContext(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame) {
RendererClientBase::DidCreateScriptContext(context, render_frame);
@ -229,7 +229,7 @@ void AtomSandboxedRendererClient::DidCreateScriptContext(
InvokeHiddenCallback(context, kLifecycleKey, "onLoaded");
}
void AtomSandboxedRendererClient::SetupMainWorldOverrides(
void ElectronSandboxedRendererClient::SetupMainWorldOverrides(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame) {
// Setup window overrides in the main world context
@ -252,7 +252,7 @@ void AtomSandboxedRendererClient::SetupMainWorldOverrides(
&isolated_bundle_params, &isolated_bundle_args, nullptr);
}
void AtomSandboxedRendererClient::SetupExtensionWorldOverrides(
void ElectronSandboxedRendererClient::SetupExtensionWorldOverrides(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame,
int world_id) {
@ -279,7 +279,7 @@ void AtomSandboxedRendererClient::SetupExtensionWorldOverrides(
#endif
}
void AtomSandboxedRendererClient::WillReleaseScriptContext(
void ElectronSandboxedRendererClient::WillReleaseScriptContext(
v8::Handle<v8::Context> context,
content::RenderFrame* render_frame) {
if (injected_frames_.erase(render_frame) == 0)

14
shell/renderer/atom_sandboxed_renderer_client.h → shell/renderer/electron_sandboxed_renderer_client.h
View file

@ -1,8 +1,8 @@
// Copyright (c) 2016 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_RENDERER_ATOM_SANDBOXED_RENDERER_CLIENT_H_
#define SHELL_RENDERER_ATOM_SANDBOXED_RENDERER_CLIENT_H_
#ifndef SHELL_RENDERER_ELECTRON_SANDBOXED_RENDERER_CLIENT_H_
#define SHELL_RENDERER_ELECTRON_SANDBOXED_RENDERER_CLIENT_H_
#include <memory>
#include <set>
@ -14,10 +14,10 @@
namespace electron {
class AtomSandboxedRendererClient : public RendererClientBase {
class ElectronSandboxedRendererClient : public RendererClientBase {
public:
AtomSandboxedRendererClient();
~AtomSandboxedRendererClient() override;
ElectronSandboxedRendererClient();
~ElectronSandboxedRendererClient() override;
void InitializeBindings(v8::Local<v8::Object> binding,
v8::Local<v8::Context> context,
@ -46,9 +46,9 @@ class AtomSandboxedRendererClient : public RendererClientBase {
// assertion, so we have to keep a book of injected web frames.
std::set<content::RenderFrame*> injected_frames_;
DISALLOW_COPY_AND_ASSIGN(AtomSandboxedRendererClient);
DISALLOW_COPY_AND_ASSIGN(ElectronSandboxedRendererClient);
};
} // namespace electron
#endif // SHELL_RENDERER_ATOM_SANDBOXED_RENDERER_CLIENT_H_
#endif // SHELL_RENDERER_ELECTRON_SANDBOXED_RENDERER_CLIENT_H_

6
shell/renderer/renderer_client_base.cc
View file

@ -24,11 +24,11 @@
#include "shell/common/color_util.h"
#include "shell/common/gin_helper/dictionary.h"
#include "shell/common/options_switches.h"
#include "shell/renderer/atom_autofill_agent.h"
#include "shell/renderer/atom_render_frame_observer.h"
#include "shell/renderer/browser_exposed_renderer_interfaces.h"
#include "shell/renderer/content_settings_observer.h"
#include "shell/renderer/electron_api_service_impl.h"
#include "shell/renderer/electron_autofill_agent.h"
#include "shell/renderer/electron_render_frame_observer.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
#include "third_party/blink/public/web/blink.h"
#include "third_party/blink/public/web/web_custom_element.h" // NOLINT(build/include_alpha)
@ -53,7 +53,7 @@
#endif
#if BUILDFLAG(ENABLE_PDF_VIEWER)
#include "shell/common/atom_constants.h"
#include "shell/common/electron_constants.h"
#endif // BUILDFLAG(ENABLE_PDF_VIEWER)
#if BUILDFLAG(ENABLE_PLUGINS)