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

Merge pull request #14972 from electron/chromium-upgrade/69

Browse source 
feat: upgrade to Chromium 69.0.3497.106
This commit is contained in:
Samuel Attard 2018-10-10 15:29:21 +11:00 • committed by GitHub
commit cc0c6ad14a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
190 changed files with 3650 additions and 7716 deletions
Download patch file Download diff file Expand all files Collapse all files

2
atom/browser/api/atom_api_app.cc
View file

@ -1173,7 +1173,7 @@ v8::Local<v8::Promise> App::GetGPUInfo(v8::Isolate* isolate,
auto* const info_mgr = GPUInfoManager::GetInstance();
if (info_type == "complete") {
#if defined(OS_MACOSX) || defined(OS_WIN)
#if defined(OS_WIN)
info_mgr->FetchCompleteInfo(promise);
#else
info_mgr->FetchBasicInfo(promise);

5
atom/browser/api/atom_api_net_log.cc
View file

@ -11,6 +11,7 @@
#include "atom/common/native_mate_converters/callback.h"
#include "atom/common/native_mate_converters/file_path_converter.h"
#include "base/command_line.h"
#include "base/logging.h"
#include "components/net_log/chrome_net_log.h"
#include "content/public/browser/storage_partition.h"
#include "native_mate/dictionary.h"
@ -103,11 +104,13 @@ void NetLog::StopLogging(mate::Arguments* args) {
void NetLog::OnNewState(const base::DictionaryValue& state) {
net_log_state_ = state.CreateDeepCopy();
auto logging_state = GetLoggingState();
LOG(INFO) << "Got new state: " << logging_state;
if (stop_callback_queue_.empty())
return;
if (GetLoggingState() == "NOT_LOGGING") {
if (logging_state == "NOT_LOGGING") {
for (auto& callback : stop_callback_queue_) {
if (!callback.is_null())
net_log_writer_->GetFilePathToCompletedLog(callback);

80
atom/browser/api/atom_api_session.cc
View file

@ -27,7 +27,6 @@
#include "atom/common/native_mate_converters/gurl_converter.h"
#include "atom/common/native_mate_converters/net_converter.h"
#include "atom/common/native_mate_converters/value_converter.h"
#include "atom/common/node_includes.h"
#include "base/files/file_path.h"
#include "base/guid.h"
#include "base/strings/string_number_conversions.h"
@ -56,10 +55,10 @@
#include "net/url_request/static_http_user_agent_settings.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "services/network/throttling/network_conditions.h"
#include "services/network/throttling/throttling_controller.h"
#include "ui/base/l10n/l10n_util.h"
#include "atom/common/node_includes.h"
using atom::api::Cookies;
using content::BrowserThread;
using content::StoragePartition;
@ -353,18 +352,6 @@ void DownloadIdCallback(content::DownloadManager* download_manager,
false, std::vector<download::DownloadItem::ReceivedSlice>());
}
void SetDevToolsNetworkEmulationClientIdInIO(
net::URLRequestContextGetter* url_request_context_getter,
const std::string& client_id) {
if (!url_request_context_getter)
return;
net::URLRequestContext* context =
url_request_context_getter->GetURLRequestContext();
AtomNetworkDelegate* network_delegate =
static_cast<AtomNetworkDelegate*>(context->network_delegate());
network_delegate->SetDevToolsNetworkEmulationClientId(client_id);
}
void DestroyGlobalHandle(v8::Isolate* isolate,
const v8::Global<v8::Value>& global_handle) {
v8::Locker locker(isolate);
@ -385,7 +372,7 @@ void DestroyGlobalHandle(v8::Isolate* isolate,
} // namespace
Session::Session(v8::Isolate* isolate, AtomBrowserContext* browser_context)
: devtools_network_emulation_client_id_(base::GenerateGUID()),
: network_emulation_token_(base::UnguessableToken::Create()),
browser_context_(browser_context) {
// Observe DownloadManager to get download notifications.
content::BrowserContext::GetDownloadManager(browser_context)
@ -503,42 +490,43 @@ void Session::SetDownloadPath(const base::FilePath& path) {
}
void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
std::unique_ptr<network::NetworkConditions> conditions;
bool offline = false;
double latency = 0.0, download_throughput = 0.0, upload_throughput = 0.0;
if (options.Get("offline", &offline) && offline) {
conditions.reset(new network::NetworkConditions(offline));
} else {
options.Get("latency", &latency);
options.Get("downloadThroughput", &download_throughput);
options.Get("uploadThroughput", &upload_throughput);
conditions.reset(new network::NetworkConditions(
false, latency, download_throughput, upload_throughput));
auto conditions = network::mojom::NetworkConditions::New();
options.Get("offline", &conditions->offline);
options.Get("downloadThroughput", &conditions->download_throughput);
options.Get("uploadThroughput", &conditions->upload_throughput);
double latency = 0.0;
if (options.Get("latency", &latency) && latency) {
conditions->latency = base::TimeDelta::FromMillisecondsD(latency);
}
network::ThrottlingController::SetConditions(
devtools_network_emulation_client_id_, std::move(conditions));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::BindOnce(&SetDevToolsNetworkEmulationClientIdInIO,
base::RetainedRef(browser_context_->GetRequestContext()),
devtools_network_emulation_client_id_));
auto* network_context = content::BrowserContext::GetDefaultStoragePartition(
browser_context_.get())
->GetNetworkContext();
network_context->SetNetworkConditions(network_emulation_token_,
std::move(conditions));
}
void Session::DisableNetworkEmulation() {
auto conditions = std::make_unique<network::NetworkConditions>();
network::ThrottlingController::SetConditions(
devtools_network_emulation_client_id_, std::move(conditions));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::BindOnce(&SetDevToolsNetworkEmulationClientIdInIO,
base::RetainedRef(browser_context_->GetRequestContext()),
std::string()));
auto* network_context = content::BrowserContext::GetDefaultStoragePartition(
browser_context_.get())
->GetNetworkContext();
network_context->SetNetworkConditions(
network_emulation_token_, network::mojom::NetworkConditions::New());
}
void WrapVerifyProc(base::Callback<void(const VerifyRequestParams& request,
base::Callback<void(int)>)> proc,
const VerifyRequestParams& request,
base::OnceCallback<void(int)> cb) {
proc.Run(request, base::AdaptCallbackForRepeating(std::move(cb)));
}
void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
mate::Arguments* args) {
AtomCertVerifier::VerifyProc proc;
base::Callback<void(const VerifyRequestParams& request,
base::Callback<void(int)>)>
proc;
if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &proc))) {
args->ThrowError("Must pass null or function");
return;
@ -548,7 +536,7 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
BrowserThread::IO, FROM_HERE,
base::BindOnce(&SetCertVerifyProcInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
proc));
base::Bind(&WrapVerifyProc, proc)));
}
void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
@ -559,7 +547,7 @@ void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
return;
}
auto* permission_manager = static_cast<AtomPermissionManager*>(
browser_context()->GetPermissionManager());
browser_context()->GetPermissionControllerDelegate());
permission_manager->SetPermissionRequestHandler(handler);
}
@ -571,7 +559,7 @@ void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val,
return;
}
auto* permission_manager = static_cast<AtomPermissionManager*>(
browser_context()->GetPermissionManager());
browser_context()->GetPermissionControllerDelegate());
permission_manager->SetPermissionCheckHandler(handler);
}

4
atom/browser/api/atom_api_session.h
View file

@ -107,8 +107,8 @@ class Session : public mate::TrackableObject<Session>,
v8::Global<v8::Value> web_request_;
v8::Global<v8::Value> net_log_;
// The X-DevTools-Emulate-Network-Conditions-Client-Id.
std::string devtools_network_emulation_client_id_;
// The client id to enable the network throttler.
base::UnguessableToken network_emulation_token_;
scoped_refptr<AtomBrowserContext> browser_context_;

27
atom/browser/api/atom_api_web_contents.cc
View file

@ -462,7 +462,7 @@ void WebContents::InitWithSessionAndOptions(v8::Isolate* isolate,
auto* relay =
NativeWindowRelay::FromWebContents(embedder_->web_contents());
if (relay)
owner_window = relay->window.get();
owner_window = relay->GetNativeWindow();
}
if (owner_window)
SetOwnerWindow(owner_window);
@ -587,8 +587,8 @@ void WebContents::BeforeUnloadFired(content::WebContents* tab,
*proceed_to_fire_unload = true;
}
void WebContents::MoveContents(content::WebContents* source,
const gfx::Rect& pos) {
void WebContents::SetContentsBounds(content::WebContents* source,
const gfx::Rect& pos) {
Emit("move", pos);
}
@ -612,10 +612,6 @@ void WebContents::UpdateTargetURL(content::WebContents* source,
Emit("update-target-url", url);
}
bool WebContents::IsPopupOrPanel(const content::WebContents* source) const {
return type_ == BROWSER_WINDOW;
}
void WebContents::HandleKeyboardEvent(
content::WebContents* source,
const content::NativeWebKeyboardEvent& event) {
@ -671,7 +667,8 @@ void WebContents::ExitFullscreenModeForTab(content::WebContents* source) {
void WebContents::RendererUnresponsive(
content::WebContents* source,
content::RenderWidgetHost* render_widget_host) {
content::RenderWidgetHost* render_widget_host,
base::RepeatingClosure hang_monitor_restarter) {
Emit("unresponsive");
}
@ -734,10 +731,10 @@ bool WebContents::CheckMediaAccessPermission(
void WebContents::RequestMediaAccessPermission(
content::WebContents* web_contents,
const content::MediaStreamRequest& request,
const content::MediaResponseCallback& callback) {
content::MediaResponseCallback callback) {
auto* permission_helper =
WebContentsPermissionHelper::FromWebContents(web_contents);
permission_helper->RequestMediaAccessPermission(request, callback);
permission_helper->RequestMediaAccessPermission(request, std::move(callback));
}
void WebContents::RequestToLockMouse(content::WebContents* web_contents,
@ -988,7 +985,8 @@ void WebContents::DevToolsOpened() {
// Inherit owner window in devtools when it doesn't have one.
auto* devtools = managed_web_contents()->GetDevToolsWebContents();
bool has_window = devtools->GetUserData(NativeWindowRelay::UserDataKey());
bool has_window =
devtools->GetUserData(NativeWindowRelay::kNativeWindowRelayUserDataKey);
if (owner_window() && !has_window)
handle->SetOwnerWindow(devtools, owner_window());
@ -1823,7 +1821,8 @@ gfx::Size WebContents::GetSizeForNewRenderView(content::WebContents* wc) const {
if (IsOffScreen() && wc == web_contents()) {
auto* relay = NativeWindowRelay::FromWebContents(web_contents());
if (relay) {
return relay->window->GetSize();
auto* owner_window = relay->GetNativeWindow();
return owner_window ? owner_window->GetSize() : gfx::Size();
}
}
@ -1916,7 +1915,7 @@ void WebContents::SetEmbedder(const WebContents* embedder) {
NativeWindow* owner_window = nullptr;
auto* relay = NativeWindowRelay::FromWebContents(embedder->web_contents());
if (relay) {
owner_window = relay->window.get();
owner_window = relay->GetNativeWindow();
}
if (owner_window)
SetOwnerWindow(owner_window);
@ -1961,7 +1960,7 @@ v8::Local<v8::Value> WebContents::Debugger(v8::Isolate* isolate) {
}
void WebContents::GrantOriginAccess(const GURL& url) {
content::ChildProcessSecurityPolicy::GetInstance()->GrantOrigin(
content::ChildProcessSecurityPolicy::GetInstance()->GrantCommitOrigin(
web_contents()->GetMainFrame()->GetProcess()->GetID(),
url::Origin::Create(url));
}

10
atom/browser/api/atom_api_web_contents.h
View file

@ -314,12 +314,11 @@ class WebContents : public mate::TrackableObject<WebContents>,
void BeforeUnloadFired(content::WebContents* tab,
bool proceed,
bool* proceed_to_fire_unload) override;
void MoveContents(content::WebContents* source,
const gfx::Rect& pos) override;
void SetContentsBounds(content::WebContents* source,
const gfx::Rect& pos) override;
void CloseContents(content::WebContents* source) override;
void ActivateContents(content::WebContents* contents) override;
void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
bool IsPopupOrPanel(const content::WebContents* source) const override;
void HandleKeyboardEvent(
content::WebContents* source,
const content::NativeWebKeyboardEvent& event) override;
@ -333,7 +332,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
void ExitFullscreenModeForTab(content::WebContents* source) override;
void RendererUnresponsive(
content::WebContents* source,
content::RenderWidgetHost* render_widget_host) override;
content::RenderWidgetHost* render_widget_host,
base::RepeatingClosure hang_monitor_restarter) override;
void RendererResponsive(
content::WebContents* source,
content::RenderWidgetHost* render_widget_host) override;
@ -351,7 +351,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
void RequestMediaAccessPermission(
content::WebContents* web_contents,
const content::MediaStreamRequest& request,
const content::MediaResponseCallback& callback) override;
content::MediaResponseCallback callback) override;
void RequestToLockMouse(content::WebContents* web_contents,
bool user_gesture,
bool last_unlocked_by_target) override;

6
atom/browser/api/atom_api_web_request.cc
View file

@ -49,11 +49,9 @@ void CallNetworkDelegateMethod(
URLPatterns patterns,
Listener listener) {
// Force creating network delegate.
net::URLRequestContext* context =
url_request_context_getter->GetURLRequestContext();
url_request_context_getter->GetURLRequestContext();
// Then call the method.
AtomNetworkDelegate* network_delegate =
static_cast<AtomNetworkDelegate*>(context->network_delegate());
auto* network_delegate = url_request_context_getter->network_delegate();
(network_delegate->*method)(type, std::move(patterns), std::move(listener));
}

12
atom/browser/api/gpu_info_enumerator.cc
View file

@ -95,6 +95,18 @@ void GPUInfoEnumerator::EndAuxAttributes() {
value_stack.pop();
}
void GPUInfoEnumerator::BeginOverlayCapability() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
}
void GPUInfoEnumerator::EndOverlayCapability() {
auto& top_value = value_stack.top();
top_value->SetDictionary(kOverlayCapabilityKey, std::move(current));
current = std::move(top_value);
value_stack.pop();
}
std::unique_ptr<base::DictionaryValue> GPUInfoEnumerator::GetDictionary() {
return std::move(current);
}

3
atom/browser/api/gpu_info_enumerator.h
View file

@ -23,6 +23,7 @@ class GPUInfoEnumerator final : public gpu::GPUInfo::Enumerator {
const char* kVideoEncodeAcceleratorSupportedProfileKey =
"videoEncodeAcceleratorSupportedProfile";
const char* kAuxAttributesKey = "auxAttributes";
const char* kOverlayCapabilityKey = "overlayCapability";
public:
GPUInfoEnumerator();
@ -41,6 +42,8 @@ class GPUInfoEnumerator final : public gpu::GPUInfo::Enumerator {
void EndVideoEncodeAcceleratorSupportedProfile() override;
void BeginAuxAttributes() override;
void EndAuxAttributes() override;
void BeginOverlayCapability() override;
void EndOverlayCapability() override;
std::unique_ptr<base::DictionaryValue> GetDictionary();
private:

6
atom/browser/api/gpuinfo_manager.cc
View file

@ -25,11 +25,9 @@ GPUInfoManager::~GPUInfoManager() {
}
// Based on
// https://chromium.googlesource.com/chromium/src.git/+/66.0.3359.181/content/browser/gpu/gpu_data_manager_impl_private.cc#810
// https://chromium.googlesource.com/chromium/src.git/+/69.0.3497.106/content/browser/gpu/gpu_data_manager_impl_private.cc#838
bool GPUInfoManager::NeedsCompleteGpuInfoCollection() {
#if defined(OS_MACOSX)
return gpu_data_manager_->GetGPUInfo().gl_vendor.empty();
#elif defined(OS_WIN)
#if defined(OS_WIN)
const auto& gpu_info = gpu_data_manager_->GetGPUInfo();
return (gpu_info.dx_diagnostics.values.empty() &&
gpu_info.dx_diagnostics.children.empty());

15
atom/browser/atom_browser_client.cc
View file

@ -55,12 +55,12 @@
#include "content/public/common/service_names.mojom.h"
#include "content/public/common/url_constants.h"
#include "content/public/common/web_preferences.h"
#include "device/geolocation/public/cpp/location_provider.h"
#include "electron/buildflags/buildflags.h"
#include "electron/grit/electron_resources.h"
#include "net/base/escape.h"
#include "net/ssl/ssl_cert_request_info.h"
#include "ppapi/host/ppapi_host.h"
#include "services/device/public/cpp/geolocation/location_provider.h"
#include "services/network/public/cpp/resource_request_body.h"
#include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
#include "ui/base/l10n/l10n_util.h"
@ -374,16 +374,6 @@ void AtomBrowserClient::DidCreatePpapiPlugin(content::BrowserPpapiHost* host) {
#endif
}
void AtomBrowserClient::GetGeolocationRequestContext(
base::OnceCallback<void(scoped_refptr<net::URLRequestContextGetter>)>
callback) {
auto* io_thread = AtomBrowserMainParts::Get()->io_thread();
auto* context = io_thread->GetRequestContext();
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(std::move(callback), base::RetainedRef(context)));
}
std::string AtomBrowserClient::GetGeolocationApiKey() {
std::unique_ptr<base::Environment> env(base::Environment::Create());
std::string api_key;
@ -537,7 +527,8 @@ network::mojom::NetworkContextPtr AtomBrowserClient::CreateNetworkContext(
void AtomBrowserClient::RegisterOutOfProcessServices(
OutOfProcessServiceMap* services) {
(*services)[proxy_resolver::mojom::kProxyResolverServiceName] =
base::ASCIIToUTF16("V8 Proxy Resolver");
base::BindRepeating(&l10n_util::GetStringUTF16,
IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME);
}
std::unique_ptr<base::Value> AtomBrowserClient::GetServiceManifestOverlay(

3
atom/browser/atom_browser_client.h
View file

@ -69,9 +69,6 @@ class AtomBrowserClient : public brightray::BrowserClient,
void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id) override;
void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
void GetGeolocationRequestContext(
base::OnceCallback<void(scoped_refptr<net::URLRequestContextGetter>)>
callback) override;
std::string GetGeolocationApiKey() override;
content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
void AllowCertificateError(

5
atom/browser/atom_browser_context.cc
View file

@ -72,7 +72,7 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
bool in_memory,
const base::DictionaryValue& options)
: base::RefCountedDeleteOnSequence<AtomBrowserContext>(
base::SequencedTaskRunnerHandle::Get()),
base::ThreadTaskRunnerHandle::Get()),
in_memory_pref_store_(nullptr),
storage_policy_(new SpecialStoragePolicy),
in_memory_(in_memory),
@ -234,7 +234,8 @@ content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
return guest_manager_.get();
}
content::PermissionManager* AtomBrowserContext::GetPermissionManager() {
content::PermissionControllerDelegate*
AtomBrowserContext::GetPermissionControllerDelegate() {
if (!permission_manager_.get())
permission_manager_.reset(new AtomPermissionManager);
return permission_manager_.get();

3
atom/browser/atom_browser_context.h
View file

@ -81,7 +81,8 @@ class AtomBrowserContext
std::string GetMediaDeviceIDSalt() override;
content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
content::BrowserPluginGuestManager* GetGuestManager() override;
content::PermissionManager* GetPermissionManager() override;
content::PermissionControllerDelegate* GetPermissionControllerDelegate()
override;
storage::SpecialStoragePolicy* GetSpecialStoragePolicy() override;
net::URLRequestContextGetter* CreateRequestContext(
content::ProtocolHandlerMap* protocol_handlers,

22
atom/browser/atom_browser_main_parts.cc
View file

@ -10,7 +10,6 @@
#include "atom/browser/api/trackable_object.h"
#include "atom/browser/atom_browser_client.h"
#include "atom/browser/atom_browser_context.h"
#include "atom/browser/bridge_task_runner.h"
#include "atom/browser/browser.h"
#include "atom/browser/io_thread.h"
#include "atom/browser/javascript_environment.h"
@ -73,7 +72,6 @@ AtomBrowserMainParts::AtomBrowserMainParts(
browser_(new Browser),
node_bindings_(NodeBindings::Create(NodeBindings::BROWSER)),
atom_bindings_(new AtomBindings(uv_default_loop())),
gc_timer_(true, true),
main_function_params_(params) {
DCHECK(!self_) << "Cannot have two AtomBrowserMainParts";
self_ = this;
@ -136,18 +134,15 @@ int AtomBrowserMainParts::PreEarlyInitialization() {
void AtomBrowserMainParts::PostEarlyInitialization() {
brightray::BrowserMainParts::PostEarlyInitialization();
// Temporary set the bridge_task_runner_ as current thread's task runner,
// so we can fool gin::PerIsolateData to use it as its task runner, instead
// of getting current message loop's task runner, which is null for now.
bridge_task_runner_ = new BridgeTaskRunner;
base::ThreadTaskRunnerHandle handle(bridge_task_runner_);
// A workaround was previously needed because there was no ThreadTaskRunner
// set. If this check is failing we may need to re-add that workaround
DCHECK(base::ThreadTaskRunnerHandle::IsSet());
// The ProxyResolverV8 has setup a complete V8 environment, in order to
// avoid conflicts we only initialize our V8 environment after that.
js_env_.reset(new JavascriptEnvironment);
js_env_.reset(new JavascriptEnvironment(node_bindings_->uv_loop()));
node_bindings_->Initialize();
// Create the global environment.
node::Environment* env = node_bindings_->CreateEnvironment(
js_env_->context(), js_env_->platform());
@ -222,8 +217,6 @@ void AtomBrowserMainParts::ToolkitInitialized() {
}
void AtomBrowserMainParts::PreMainMessageLoopRun() {
js_env_->OnMessageLoopCreated();
// Run user's main script before most things get initialized, so we can have
// a chance to setup everything.
node_bindings_->PrepareMessageLoop();
@ -244,8 +237,6 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
#endif // BUILDFLAG(ENABLE_PDF_VIEWER)
brightray::BrowserMainParts::PreMainMessageLoopRun();
bridge_task_runner_->MessageLoopIsReady();
bridge_task_runner_ = nullptr;
#if defined(USE_X11)
libgtkui::GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
@ -266,6 +257,11 @@ bool AtomBrowserMainParts::MainMessageLoopRun(int* result_code) {
return brightray::BrowserMainParts::MainMessageLoopRun(result_code);
}
void AtomBrowserMainParts::PreDefaultMainMessageLoopRun(
base::OnceClosure quit_closure) {
Browser::SetMainMessageLoopQuitClosure(std::move(quit_closure));
}
void AtomBrowserMainParts::PostMainMessageLoopStart() {
brightray::BrowserMainParts::PostMainMessageLoopStart();
#if defined(OS_POSIX)

7
atom/browser/atom_browser_main_parts.h
View file

@ -81,6 +81,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
void ToolkitInitialized() override;
void PreMainMessageLoopRun() override;
bool MainMessageLoopRun(int* result_code) override;
void PreDefaultMainMessageLoopRun(base::OnceClosure quit_closure) override;
void PostMainMessageLoopStart() override;
void PostMainMessageLoopRun() override;
#if defined(OS_MACOSX)
@ -108,10 +109,6 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
// A fake BrowserProcess object that used to feed the source code from chrome.
std::unique_ptr<BrowserProcess> fake_browser_process_;
// The gin::PerIsolateData requires a task runner to create, so we feed it
// with a task runner that will post all work to main loop.
scoped_refptr<BridgeTaskRunner> bridge_task_runner_;
// Pointer to exit code.
int* exit_code_ = nullptr;
@ -125,7 +122,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
std::unique_ptr<net_log::ChromeNetLog> net_log_;
std::unique_ptr<IconManager> icon_manager_;
base::Timer gc_timer_;
base::RepeatingTimer gc_timer_;
// List of callbacks should be executed before destroying JS env.
std::list<base::OnceClosure> destructors_;

4
atom/browser/atom_browser_main_parts_mac.mm
View file

@ -4,7 +4,6 @@
#include "atom/browser/atom_browser_main_parts.h"
#include "atom/browser/mac/atom_application.h"
#include "atom/browser/mac/atom_application_delegate.h"
#include "base/mac/bundle_locations.h"
#include "base/mac/foundation_util.h"
@ -13,9 +12,6 @@
namespace atom {
void AtomBrowserMainParts::PreMainMessageLoopStart() {
// Force the NSApplication subclass to be used.
[AtomApplication sharedApplication];
// Set our own application delegate.
AtomApplicationDelegate* delegate = [[AtomApplicationDelegate alloc] init];
[NSApp setDelegate:delegate];

2
atom/browser/atom_download_manager_delegate.cc
View file

@ -86,7 +86,7 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
auto* relay =
web_contents ? NativeWindowRelay::FromWebContents(web_contents) : nullptr;
if (relay)
window = relay->window.get();
window = relay->GetNativeWindow();
auto* web_preferences = WebContentsPreferences::From(web_contents);
bool offscreen =

2
atom/browser/atom_javascript_dialog_manager.cc
View file

@ -72,7 +72,7 @@ void AtomJavaScriptDialogManager::RunJavaScriptDialog(
if (web_preferences && !web_preferences->IsEnabled(options::kOffscreen)) {
auto* relay = NativeWindowRelay::FromWebContents(web_contents);
if (relay)
window = relay->window.get();
window = relay->GetNativeWindow();
}
atom::ShowMessageBox(

10
atom/browser/atom_permission_manager.cc
View file

@ -11,6 +11,7 @@
#include "atom/browser/atom_browser_main_parts.h"
#include "atom/browser/web_contents_preferences.h"
#include "content/public/browser/child_process_security_policy.h"
#include "content/public/browser/permission_controller.h"
#include "content/public/browser/permission_type.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
@ -111,7 +112,8 @@ int AtomPermissionManager::RequestPermission(
content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin,
bool user_gesture,
const StatusCallback& response_callback) {
const base::Callback<void(blink::mojom::PermissionStatus)>&
response_callback) {
return RequestPermissionWithDetails(permission, render_frame_host,
requesting_origin, user_gesture, nullptr,
response_callback);
@ -150,7 +152,7 @@ int AtomPermissionManager::RequestPermissionsWithDetails(
const StatusesCallback& response_callback) {
if (permissions.empty()) {
response_callback.Run(std::vector<blink::mojom::PermissionStatus>());
return kNoPendingOperation;
return content::PermissionController::kNoPendingOperation;
}
if (request_handler_.is_null()) {
@ -168,7 +170,7 @@ int AtomPermissionManager::RequestPermissionsWithDetails(
statuses.push_back(blink::mojom::PermissionStatus::GRANTED);
}
response_callback.Run(statuses);
return kNoPendingOperation;
return content::PermissionController::kNoPendingOperation;
}
auto* web_contents =
@ -222,7 +224,7 @@ int AtomPermissionManager::SubscribePermissionStatusChange(
content::PermissionType permission,
const GURL& requesting_origin,
const GURL& embedding_origin,
const StatusCallback& callback) {
const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
return -1;
}

10
atom/browser/atom_permission_manager.h
View file

@ -12,7 +12,7 @@
#include "base/callback.h"
#include "base/containers/id_map.h"
#include "base/values.h"
#include "content/public/browser/permission_manager.h"
#include "content/public/browser/permission_controller_delegate.h"
namespace content {
class WebContents;
@ -20,7 +20,7 @@ class WebContents;
namespace atom {
class AtomPermissionManager : public content::PermissionManager {
class AtomPermissionManager : public content::PermissionControllerDelegate {
public:
AtomPermissionManager();
~AtomPermissionManager() override;
@ -41,7 +41,7 @@ class AtomPermissionManager : public content::PermissionManager {
void SetPermissionRequestHandler(const RequestHandler& handler);
void SetPermissionCheckHandler(const CheckHandler& handler);
// content::PermissionManager:
// content::PermissionControllerDelegate:
int RequestPermission(
content::PermissionType permission,
content::RenderFrameHost* render_frame_host,
@ -55,7 +55,7 @@ class AtomPermissionManager : public content::PermissionManager {
const GURL& requesting_origin,
bool user_gesture,
const base::DictionaryValue* details,
const base::Callback<void(blink::mojom::PermissionStatus)>& callback);
const StatusCallback& callback);
int RequestPermissions(
const std::vector<content::PermissionType>& permissions,
content::RenderFrameHost* render_frame_host,
@ -87,7 +87,7 @@ class AtomPermissionManager : public content::PermissionManager {
int permission_id,
blink::mojom::PermissionStatus status);
// content::PermissionManager:
// content::PermissionControllerDelegate:
void ResetPermission(content::PermissionType permission,
const GURL& requesting_origin,
const GURL& embedding_origin) override;

4
atom/browser/atom_speech_recognition_manager_delegate.cc
View file

@ -32,11 +32,11 @@ void AtomSpeechRecognitionManagerDelegate::OnRecognitionEnd(int session_id) {}
void AtomSpeechRecognitionManagerDelegate::OnRecognitionResults(
int session_id,
const content::SpeechRecognitionResults& result) {}
const std::vector<blink::mojom::SpeechRecognitionResultPtr>& results) {}
void AtomSpeechRecognitionManagerDelegate::OnRecognitionError(
int session_id,
const content::SpeechRecognitionError& error) {}
const blink::mojom::SpeechRecognitionError& error) {}
void AtomSpeechRecognitionManagerDelegate::OnAudioLevelsChange(
int session_id,

5
atom/browser/atom_speech_recognition_manager_delegate.h
View file

@ -6,6 +6,7 @@
#define ATOM_BROWSER_ATOM_SPEECH_RECOGNITION_MANAGER_DELEGATE_H_
#include <string>
#include <vector>
#include "base/macros.h"
#include "content/public/browser/speech_recognition_event_listener.h"
@ -30,10 +31,10 @@ class AtomSpeechRecognitionManagerDelegate
void OnRecognitionEnd(int session_id) override;
void OnRecognitionResults(
int session_id,
const content::SpeechRecognitionResults& result) override;
const std::vector<blink::mojom::SpeechRecognitionResultPtr>&) override;
void OnRecognitionError(
int session_id,
const content::SpeechRecognitionError& error) override;
const blink::mojom::SpeechRecognitionError& error) override;
void OnAudioLevelsChange(int session_id,
float volume,
float noise_volume) override;

4
atom/browser/atom_web_ui_controller_factory.cc
View file

@ -52,7 +52,7 @@ bool AtomWebUIControllerFactory::UseWebUIBindingsForURL(
return UseWebUIForURL(browser_context, url);
}
content::WebUIController*
std::unique_ptr<content::WebUIController>
AtomWebUIControllerFactory::CreateWebUIControllerForURL(content::WebUI* web_ui,
const GURL& url) const {
#if BUILDFLAG(ENABLE_PDF_VIEWER)
@ -78,7 +78,7 @@ AtomWebUIControllerFactory::CreateWebUIControllerForURL(content::WebUI* web_ui,
return new PdfViewerUI(browser_context, web_ui, src);
}
#endif // BUILDFLAG(ENABLE_PDF_VIEWER)
return nullptr;
return std::unique_ptr<content::WebUIController>();
}
} // namespace atom

5
atom/browser/atom_web_ui_controller_factory.h
View file

@ -5,8 +5,11 @@
#ifndef ATOM_BROWSER_ATOM_WEB_UI_CONTROLLER_FACTORY_H_
#define ATOM_BROWSER_ATOM_WEB_UI_CONTROLLER_FACTORY_H_
#include <memory>
#include "base/macros.h"
#include "base/memory/singleton.h"
#include "content/public/browser/web_ui_controller.h"
#include "content/public/browser/web_ui_controller_factory.h"
namespace atom {
@ -25,7 +28,7 @@ class AtomWebUIControllerFactory : public content::WebUIControllerFactory {
const GURL& url) const override;
bool UseWebUIBindingsForURL(content::BrowserContext* browser_context,
const GURL& url) const override;
content::WebUIController* CreateWebUIControllerForURL(
std::unique_ptr<content::WebUIController> CreateWebUIControllerForURL(
content::WebUI* web_ui,
const GURL& url) const override;

65
atom/browser/bridge_task_runner.cc
View file

@ -1,65 +0,0 @@
// Copyright (c) 2015 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/bridge_task_runner.h"
#include <utility>
#include "base/message_loop/message_loop.h"
namespace atom {
BridgeTaskRunner::BridgeTaskRunner() = default;
BridgeTaskRunner::~BridgeTaskRunner() = default;
void BridgeTaskRunner::MessageLoopIsReady() {
auto message_loop = base::MessageLoop::current();
CHECK(message_loop);
for (TaskPair& task : tasks_) {
message_loop->task_runner()->PostDelayedTask(
std::get<0>(task), std::move(std::get<1>(task)), std::get<2>(task));
}
for (TaskPair& task : non_nestable_tasks_) {
message_loop->task_runner()->PostNonNestableDelayedTask(
std::get<0>(task), std::move(std::get<1>(task)), std::get<2>(task));
}
}
bool BridgeTaskRunner::PostDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) {
auto message_loop = base::MessageLoop::current();
if (!message_loop) {
tasks_.push_back(std::make_tuple(from_here, std::move(task), delay));
return true;
}
return message_loop->task_runner()->PostDelayedTask(from_here,
std::move(task), delay);
}
bool BridgeTaskRunner::RunsTasksInCurrentSequence() const {
auto message_loop = base::MessageLoop::current();
if (!message_loop)
return true;
return message_loop->task_runner()->RunsTasksInCurrentSequence();
}
bool BridgeTaskRunner::PostNonNestableDelayedTask(
const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) {
auto message_loop = base::MessageLoop::current();
if (!message_loop) {
non_nestable_tasks_.push_back(
std::make_tuple(from_here, std::move(task), delay));
return true;
}
return message_loop->task_runner()->PostNonNestableDelayedTask(
from_here, std::move(task), delay);
}
} // namespace atom

48
atom/browser/bridge_task_runner.h
View file

@ -1,48 +0,0 @@
// Copyright (c) 2015 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
#define ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
#include <tuple>
#include <vector>
#include "base/location.h"
#include "base/single_thread_task_runner.h"
#include "base/tuple.h"
namespace atom {
// Post all tasks to the current message loop's task runner if available,
// otherwise delay the work until message loop is ready.
class BridgeTaskRunner : public base::SingleThreadTaskRunner {
public:
BridgeTaskRunner();
// Called when message loop is ready.
void MessageLoopIsReady();
// base::SingleThreadTaskRunner:
bool PostDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksInCurrentSequence() const override;
bool PostNonNestableDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override;
private:
using TaskPair =
std::tuple<base::Location, base::OnceClosure, base::TimeDelta>;
~BridgeTaskRunner() override;
std::vector<TaskPair> tasks_;
std::vector<TaskPair> non_nestable_tasks_;
DISALLOW_COPY_AND_ASSIGN(BridgeTaskRunner);
};
} // namespace atom
#endif // ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_

14
atom/browser/browser.cc
View file

@ -6,6 +6,7 @@
#include <memory>
#include <string>
#include <utility>
#include "atom/browser/atom_browser_main_parts.h"
#include "atom/browser/browser_observer.h"
@ -14,6 +15,7 @@
#include "atom/browser/window_list.h"
#include "base/files/file_util.h"
#include "base/message_loop/message_loop.h"
#include "base/no_destructor.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/threading/thread_restrictions.h"
@ -23,6 +25,9 @@
namespace atom {
// Null until/unless the default main message loop is running.
base::NoDestructor<base::OnceClosure> g_quit_main_message_loop;
Browser::LoginItemSettings::LoginItemSettings() = default;
Browser::LoginItemSettings::~LoginItemSettings() = default;
Browser::LoginItemSettings::LoginItemSettings(const LoginItemSettings& other) =
@ -90,9 +95,8 @@ void Browser::Shutdown() {
for (BrowserObserver& observer : observers_)
observer.OnQuit();
if (base::ThreadTaskRunnerHandle::IsSet()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::RunLoop::QuitCurrentWhenIdleClosureDeprecated());
if (*g_quit_main_message_loop) {
std::move(*g_quit_main_message_loop).Run();
} else {
// There is no message loop available so we are in early stage.
exit(0);
@ -191,6 +195,10 @@ void Browser::PreMainMessageLoopRun() {
}
}
void Browser::SetMainMessageLoopQuitClosure(base::OnceClosure quit_closure) {
*g_quit_main_message_loop = std::move(quit_closure);
}
void Browser::NotifyAndShutdown() {
if (is_shutdown_)
return;

4
atom/browser/browser.h
View file

@ -239,6 +239,10 @@ class Browser : public WindowListObserver {
void PreMainMessageLoopRun();
// Stores the supplied |quit_closure|, to be run when the last Browser
// instance is destroyed.
static void SetMainMessageLoopQuitClosure(base::OnceClosure quit_closure);
void AddObserver(BrowserObserver* obs) { observers_.AddObserver(obs); }
void RemoveObserver(BrowserObserver* obs) { observers_.RemoveObserver(obs); }

27
atom/browser/common_web_contents_delegate.cc
View file

@ -189,24 +189,35 @@ void CommonWebContentsDelegate::SetOwnerWindow(NativeWindow* owner_window) {
void CommonWebContentsDelegate::SetOwnerWindow(
content::WebContents* web_contents,
NativeWindow* owner_window) {
owner_window_ = owner_window ? owner_window->GetWeakPtr() : nullptr;
auto relay = std::make_unique<NativeWindowRelay>(owner_window_);
auto* relay_key = relay->key;
if (owner_window) {
owner_window_ = owner_window->GetWeakPtr();
#if defined(TOOLKIT_VIEWS) && !defined(OS_MACOSX)
autofill_popup_.reset(new AutofillPopup());
#endif
web_contents->SetUserData(relay_key, std::move(relay));
NativeWindowRelay::CreateForWebContents(web_contents,
owner_window->GetWeakPtr());
} else {
web_contents->RemoveUserData(relay_key);
relay.reset();
owner_window_ = nullptr;
web_contents->RemoveUserData(
NativeWindowRelay::kNativeWindowRelayUserDataKey);
}
}
void CommonWebContentsDelegate::ResetManagedWebContents(bool async) {
if (async) {
base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
web_contents_.release());
// Browser context should be destroyed only after the WebContents,
// this is guaranteed in the sync mode by the order of declaration,
// in the async version we maintain a reference until the WebContents
// is destroyed.
// //electron/patches/common/chromium/content_browser_main_loop.patch
// is required to get the right quit closure for the main message loop.
base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
FROM_HERE,
base::BindOnce([](scoped_refptr<AtomBrowserContext> browser_context,
std::unique_ptr<brightray::InspectableWebContents>
web_contents) { web_contents.reset(); },
base::RetainedRef(browser_context_),
std::move(web_contents_)));
} else {
web_contents_.reset();
}

2
atom/browser/fake_location_provider.h
View file

@ -6,7 +6,7 @@
#define ATOM_BROWSER_FAKE_LOCATION_PROVIDER_H_
#include "base/macros.h"
#include "device/geolocation/public/cpp/location_provider.h"
#include "services/device/public/cpp/geolocation/location_provider.h"
#include "services/device/public/mojom/geoposition.mojom.h"
namespace atom {

38
atom/browser/io_thread.cc
View file

@ -3,13 +3,16 @@
// found in the LICENSE file.
#include "atom/browser/io_thread.h"
#include "atom/common/options_switches.h"
#include "components/net_log/chrome_net_log.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/network_service_instance.h"
#include "net/proxy_resolution/proxy_resolution_service.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_builder.h"
#include "net/url_request/url_request_context_getter.h"
#include "services/network/network_service.h"
#if defined(USE_NSS_CERTS)
#include "net/cert_net/nss_ocsp.h"
@ -24,6 +27,33 @@ using content::BrowserThread;
namespace atom {
namespace {
network::mojom::HttpAuthStaticParamsPtr CreateHttpAuthStaticParams() {
network::mojom::HttpAuthStaticParamsPtr auth_static_params =
network::mojom::HttpAuthStaticParams::New();
auth_static_params->supported_schemes = {"basic", "digest", "ntlm",
"negotiate"};
return auth_static_params;
}
network::mojom::HttpAuthDynamicParamsPtr CreateHttpAuthDynamicParams(
const base::CommandLine& command_line) {
network::mojom::HttpAuthDynamicParamsPtr auth_dynamic_params =
network::mojom::HttpAuthDynamicParams::New();
auth_dynamic_params->server_whitelist =
command_line.GetSwitchValueASCII(switches::kAuthServerWhitelist);
auth_dynamic_params->delegate_whitelist = command_line.GetSwitchValueASCII(
switches::kAuthNegotiateDelegateWhitelist);
return auth_dynamic_params;
}
} // namespace
IOThread::IOThread(net_log::ChromeNetLog* net_log) : net_log_(net_log) {
BrowserThread::SetIOThreadDelegate(this);
}
@ -33,6 +63,14 @@ IOThread::~IOThread() {
}
void IOThread::Init() {
// Create the network service, so that shared host resolver
// gets created which is required to set the auth preferences below.
auto& command_line = *base::CommandLine::ForCurrentProcess();
auto* network_service = content::GetNetworkServiceImpl();
network_service->SetUpHttpAuth(CreateHttpAuthStaticParams());
network_service->ConfigureHttpAuthPrefs(
CreateHttpAuthDynamicParams(command_line));
net::URLRequestContextBuilder builder;
// TODO(deepak1556): We need to respoect user proxy configurations,
// the following initialization has to happen before any request

32
atom/browser/javascript_environment.cc
View file

@ -19,10 +19,13 @@
namespace atom {
JavascriptEnvironment::JavascriptEnvironment()
: initialized_(Initialize()),
isolate_holder_(base::ThreadTaskRunnerHandle::Get()),
isolate_(isolate_holder_.isolate()),
JavascriptEnvironment::JavascriptEnvironment(uv_loop_t* event_loop)
: isolate_(Initialize(event_loop)),
isolate_holder_(base::ThreadTaskRunnerHandle::Get(),
gin::IsolateHolder::kSingleThread,
gin::IsolateHolder::kAllowAtomicsWait,
gin::IsolateHolder::IsolateCreationMode::kNormal,
isolate_),
isolate_scope_(isolate_),
locker_(isolate_),
handle_scope_(isolate_),
@ -31,15 +34,7 @@ JavascriptEnvironment::JavascriptEnvironment()
JavascriptEnvironment::~JavascriptEnvironment() = default;
void JavascriptEnvironment::OnMessageLoopCreated() {
isolate_holder_.AddRunMicrotasksObserver();
}
void JavascriptEnvironment::OnMessageLoopDestroying() {
isolate_holder_.RemoveRunMicrotasksObserver();
}
bool JavascriptEnvironment::Initialize() {
v8::Isolate* JavascriptEnvironment::Initialize(uv_loop_t* event_loop) {
auto* cmd = base::CommandLine::ForCurrentProcess();
// --js-flags.
@ -54,12 +49,21 @@ bool JavascriptEnvironment::Initialize() {
platform_ = node::CreatePlatform(
base::RecommendedMaxNumberOfThreadsInPool(3, 8, 0.1, 0),
tracing_controller);
v8::V8::InitializePlatform(platform_);
gin::IsolateHolder::Initialize(
gin::IsolateHolder::kNonStrictMode, gin::IsolateHolder::kStableV8Extras,
gin::ArrayBufferAllocator::SharedInstance(),
nullptr /* external_reference_table */, false /* create_v8_platform */);
return true;
v8::Isolate* isolate = v8::Isolate::Allocate();
platform_->RegisterIsolate(isolate, event_loop);
return isolate;
}
void JavascriptEnvironment::OnMessageLoopDestroying() {
platform_->UnregisterIsolate(isolate_);
}
NodeEnvironment::NodeEnvironment(node::Environment* env) : env_(env) {}

12
atom/browser/javascript_environment.h
View file

@ -7,6 +7,7 @@
#include "base/macros.h"
#include "gin/public/isolate_holder.h"
#include "uv.h" // NOLINT(build/include)
namespace node {
class Environment;
@ -18,10 +19,9 @@ namespace atom {
// Manage the V8 isolate and context automatically.
class JavascriptEnvironment {
public:
JavascriptEnvironment();
explicit JavascriptEnvironment(uv_loop_t* event_loop);
~JavascriptEnvironment();
void OnMessageLoopCreated();
void OnMessageLoopDestroying();
node::MultiIsolatePlatform* platform() const { return platform_; }
@ -31,18 +31,16 @@ class JavascriptEnvironment {
}
private:
bool Initialize();
v8::Isolate* Initialize(uv_loop_t* event_loop);
// Leaked on exit.
node::MultiIsolatePlatform* platform_;
bool initialized_;
gin::IsolateHolder isolate_holder_;
v8::Isolate* isolate_;
gin::IsolateHolder isolate_holder_;
v8::Isolate::Scope isolate_scope_;
v8::Locker locker_;
v8::HandleScope handle_scope_;
v8::UniquePersistent<v8::Context> context_;
v8::Global<v8::Context> context_;
v8::Context::Scope context_scope_;
DISALLOW_COPY_AND_ASSIGN(JavascriptEnvironment);

2
atom/browser/login_handler.cc
View file

@ -21,7 +21,7 @@ namespace atom {
LoginHandler::LoginHandler(
net::URLRequest* request,
const net::AuthChallengeInfo& auth_info,
const net::NetworkDelegate::AuthCallback& callback,
net::NetworkDelegate::AuthCallback callback,
net::AuthCredentials* credentials,
const content::ResourceRequestInfo* resource_request_info)
: credentials_(credentials),

3
atom/browser/login_handler.h
View file

@ -8,6 +8,7 @@
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/sequenced_task_runner_helpers.h"
#include "base/strings/string16.h"
#include "content/public/browser/resource_request_info.h"
#include "net/base/network_delegate.h"
@ -23,7 +24,7 @@ class LoginHandler : public base::RefCountedThreadSafe<LoginHandler> {
public:
LoginHandler(net::URLRequest* request,
const net::AuthChallengeInfo& auth_info,
const net::NetworkDelegate::AuthCallback& callback,
net::NetworkDelegate::AuthCallback callback,
net::AuthCredentials* credentials,
const content::ResourceRequestInfo* resource_request_info);

18
atom/browser/native_window.cc
View file

@ -21,8 +21,6 @@
#include "ui/display/win/screen_win.h"
#endif
DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::NativeWindowRelay);
namespace atom {
namespace {
@ -577,8 +575,22 @@ const views::Widget* NativeWindow::GetWidget() const {
return widget();
}
// static
const void* const NativeWindowRelay::kNativeWindowRelayUserDataKey =
&NativeWindowRelay::kNativeWindowRelayUserDataKey;
// static
void NativeWindowRelay::CreateForWebContents(
content::WebContents* web_contents,
base::WeakPtr<NativeWindow> window) {
DCHECK(web_contents);
DCHECK(!web_contents->GetUserData(kNativeWindowRelayUserDataKey));
web_contents->SetUserData(kNativeWindowRelayUserDataKey,
base::WrapUnique(new NativeWindowRelay(window)));
}
NativeWindowRelay::NativeWindowRelay(base::WeakPtr<NativeWindow> window)
: key(UserDataKey()), window(window) {}
: native_window_(window) {}
NativeWindowRelay::~NativeWindowRelay() = default;

16
atom/browser/native_window.h
View file

@ -346,18 +346,20 @@ class NativeWindow : public base::SupportsUserData,
class NativeWindowRelay
: public content::WebContentsUserData<NativeWindowRelay> {
public:
explicit NativeWindowRelay(base::WeakPtr<NativeWindow> window);
static const void* const kNativeWindowRelayUserDataKey;
static void CreateForWebContents(content::WebContents*,
base::WeakPtr<NativeWindow>);
~NativeWindowRelay() override;
static void* UserDataKey() {
return content::WebContentsUserData<NativeWindowRelay>::UserDataKey();
}
void* key;
base::WeakPtr<NativeWindow> window;
NativeWindow* GetNativeWindow() const { return native_window_.get(); }
private:
friend class content::WebContentsUserData<NativeWindow>;
explicit NativeWindowRelay(base::WeakPtr<NativeWindow> window);
base::WeakPtr<NativeWindow> native_window_;
};
} // namespace atom

10
atom/browser/native_window_mac.mm
View file

@ -999,15 +999,7 @@ bool NativeWindowMac::IsKiosk() {
void NativeWindowMac::SetBackgroundColor(SkColor color) {
base::ScopedCFTypeRef<CGColorRef> cgcolor(
skia::CGColorCreateFromSkColor(color));
// views::Widget adds a layer for the content view.
auto* bridge = views::NativeWidgetMac::GetBridgeForNativeWindow(window_);
NSView* compositor_superview =
static_cast<ui::AcceleratedWidgetMacNSView*>(bridge)
->AcceleratedWidgetGetNSView();
[[compositor_superview layer] setBackgroundColor:cgcolor];
// When using WebContents as content view, the contentView also has layer.
if ([[window_ contentView] wantsLayer])
[[[window_ contentView] layer] setBackgroundColor:cgcolor];
[[[window_ contentView] layer] setBackgroundColor:cgcolor];
}
void NativeWindowMac::SetHasShadow(bool has_shadow) {

4
atom/browser/net/asar/url_request_asar_job.cc
View file

@ -142,7 +142,8 @@ int URLRequestAsarJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
}
bool URLRequestAsarJob::IsRedirectResponse(GURL* location,
int* http_status_code) {
int* http_status_code,
bool* insecure_scheme_was_upgraded) {
if (type_ != TYPE_FILE)
return false;
#if defined(OS_WIN)
@ -161,6 +162,7 @@ bool URLRequestAsarJob::IsRedirectResponse(GURL* location,
*location = net::FilePathToFileURL(new_path);
*http_status_code = 301;
*insecure_scheme_was_upgraded = false;
return true;
#else
return false;

4
atom/browser/net/asar/url_request_asar_job.h
View file

@ -55,7 +55,9 @@ class URLRequestAsarJob : public net::URLRequestJob {
void Start() override;
void Kill() override;
int ReadRawData(net::IOBuffer* buf, int buf_size) override;
bool IsRedirectResponse(GURL* location, int* http_status_code) override;
bool IsRedirectResponse(GURL* location,
int* http_status_code,
bool* insecure_scheme_was_upgraded) override;
std::unique_ptr<net::SourceStream> SetUpSourceStream() override;
bool GetMimeType(std::string* mime_type) const override;
void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers) override;

26
atom/browser/net/atom_cert_verifier.cc
View file

@ -30,14 +30,14 @@ namespace {
class Response : public base::LinkNode<Response> {
public:
Response(net::CertVerifyResult* verify_result,
const net::CompletionCallback& callback)
: verify_result_(verify_result), callback_(callback) {}
net::CompletionOnceCallback callback)
: verify_result_(verify_result), callback_(std::move(callback)) {}
net::CertVerifyResult* verify_result() { return verify_result_; }
net::CompletionCallback callback() { return callback_; }
net::CompletionOnceCallback callback() { return std::move(callback_); }
private:
net::CertVerifyResult* verify_result_;
net::CompletionCallback callback_;
net::CompletionOnceCallback callback_;
DISALLOW_COPY_AND_ASSIGN(Response);
};
@ -130,8 +130,8 @@ class CertVerifierRequest : public AtomCertVerifier::Request {
}
void AddResponseListener(net::CertVerifyResult* verify_result,
const net::CompletionCallback& callback) {
response_list_.Append(new Response(verify_result, callback));
net::CompletionOnceCallback callback) {
response_list_.Append(new Response(verify_result, std::move(callback)));
}
const AtomCertVerifier::RequestParams& params() const { return params_; }
@ -163,15 +163,15 @@ void AtomCertVerifier::SetVerifyProc(const VerifyProc& proc) {
int AtomCertVerifier::Verify(const RequestParams& params,
net::CRLSet* crl_set,
net::CertVerifyResult* verify_result,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
std::unique_ptr<Request>* out_req,
const net::NetLogWithSource& net_log) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (verify_proc_.is_null()) {
ct_delegate_->ClearCTExcludedHostsList();
return default_cert_verifier_->Verify(params, crl_set, verify_result,
callback, out_req, net_log);
return default_cert_verifier_->Verify(
params, crl_set, verify_result, std::move(callback), out_req, net_log);
} else {
CertVerifierRequest* request = FindRequest(params);
if (!request) {
@ -182,18 +182,12 @@ int AtomCertVerifier::Verify(const RequestParams& params,
*out_req = std::move(new_request);
inflight_requests_[params] = request;
}
request->AddResponseListener(verify_result, callback);
request->AddResponseListener(verify_result, std::move(callback));
return net::ERR_IO_PENDING;
}
}
bool AtomCertVerifier::SupportsOCSPStapling() {
if (verify_proc_.is_null())
return default_cert_verifier_->SupportsOCSPStapling();
return false;
}
void AtomCertVerifier::RemoveRequest(const RequestParams& params) {
auto it = inflight_requests_.find(params);
if (it != inflight_requests_.end())

5
atom/browser/net/atom_cert_verifier.h
View file

@ -38,7 +38,7 @@ class AtomCertVerifier : public net::CertVerifier {
~AtomCertVerifier() override;
using VerifyProc = base::Callback<void(const VerifyRequestParams& request,
const net::CompletionCallback&)>;
net::CompletionOnceCallback)>;
void SetVerifyProc(const VerifyProc& proc);
@ -53,10 +53,9 @@ class AtomCertVerifier : public net::CertVerifier {
int Verify(const RequestParams& params,
net::CRLSet* crl_set,
net::CertVerifyResult* verify_result,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
std::unique_ptr<Request>* out_req,
const net::NetLogWithSource& net_log) override;
bool SupportsOCSPStapling() override;
private:
friend class CertVerifierRequest;

43
atom/browser/net/atom_network_delegate.cc
View file

@ -20,10 +20,8 @@
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/url_request/url_request.h"
#include "services/network/throttling/throttling_network_transaction.h"
using content::BrowserThread;
using network::ThrottlingNetworkTransaction;
namespace atom {
@ -269,14 +267,9 @@ void AtomNetworkDelegate::SetResponseListenerInIO(ResponseEvent type,
response_listeners_[type] = {std::move(patterns), std::move(callback)};
}
void AtomNetworkDelegate::SetDevToolsNetworkEmulationClientId(
const std::string& client_id) {
client_id_ = client_id;
}
int AtomNetworkDelegate::OnBeforeURLRequest(
net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
GURL* new_url) {
if (!base::ContainsKey(response_listeners_, kOnBeforeRequest)) {
for (const auto& domain : ignore_connections_limit_domains_) {
@ -290,22 +283,19 @@ int AtomNetworkDelegate::OnBeforeURLRequest(
return net::OK;
}
return HandleResponseEvent(kOnBeforeRequest, request, callback, new_url);
return HandleResponseEvent(kOnBeforeRequest, request, std::move(callback),
new_url);
}
int AtomNetworkDelegate::OnBeforeStartTransaction(
net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
net::HttpRequestHeaders* headers) {
if (!client_id_.empty())
headers->SetHeader(network::ThrottlingNetworkTransaction::
kDevToolsEmulateNetworkConditionsClientId,
client_id_);
if (!base::ContainsKey(response_listeners_, kOnBeforeSendHeaders))
return net::OK;
return HandleResponseEvent(kOnBeforeSendHeaders, request, callback, headers,
*headers);
return HandleResponseEvent(kOnBeforeSendHeaders, request, std::move(callback),
headers, *headers);
}
void AtomNetworkDelegate::OnStartTransaction(
@ -319,7 +309,7 @@ void AtomNetworkDelegate::OnStartTransaction(
int AtomNetworkDelegate::OnHeadersReceived(
net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
const net::HttpResponseHeaders* original,
scoped_refptr<net::HttpResponseHeaders>* override,
GURL* allowed) {
@ -327,7 +317,7 @@ int AtomNetworkDelegate::OnHeadersReceived(
return net::OK;
return HandleResponseEvent(
kOnHeadersReceived, request, callback,
kOnHeadersReceived, request, std::move(callback),
std::make_pair(override, original->GetStatusLine()), original);
}
@ -353,14 +343,16 @@ void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request,
request->was_cached());
}
void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
void AtomNetworkDelegate::OnCompleted(net::URLRequest* request,
bool started,
int net_error) {
// OnCompleted may happen before other events.
callbacks_.erase(request->identifier());
if (request->status().status() == net::URLRequestStatus::FAILED ||
request->status().status() == net::URLRequestStatus::CANCELED) {
// Error event.
OnErrorOccurred(request, started);
OnErrorOccurred(request, started, net_error);
return;
}
@ -391,7 +383,7 @@ void AtomNetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) {
net::NetworkDelegate::AuthRequiredResponse AtomNetworkDelegate::OnAuthRequired(
net::URLRequest* request,
const net::AuthChallengeInfo& auth_info,
const AuthCallback& callback,
AuthCallback callback,
net::AuthCredentials* credentials) {
auto* resource_request_info =
content::ResourceRequestInfo::ForRequest(request);
@ -462,7 +454,8 @@ bool AtomNetworkDelegate::OnCanUseReportingClient(const url::Origin& origin,
}
void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request,
bool started) {
bool started,
int net_error) {
if (!base::ContainsKey(simple_listeners_, kOnErrorOccurred))
return;
@ -474,7 +467,7 @@ template <typename Out, typename... Args>
int AtomNetworkDelegate::HandleResponseEvent(
ResponseEvent type,
net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
Out out,
Args... args) {
const auto& info = response_listeners_[type];
@ -489,7 +482,7 @@ int AtomNetworkDelegate::HandleResponseEvent(
request, &render_process_id, &render_frame_id);
// The |request| could be destroyed before the |callback| is called.
callbacks_[request->identifier()] = callback;
callbacks_[request->identifier()] = std::move(callback);
ResponseCallback response =
base::Bind(&AtomNetworkDelegate::OnListenerResultInUI<Out>,
@ -535,7 +528,7 @@ void AtomNetworkDelegate::OnListenerResultInIO(
bool cancel = false;
response->GetBoolean("cancel", &cancel);
callbacks_[id].Run(cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK);
std::move(callbacks_[id]).Run(cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK);
}
template <typename T>

23
atom/browser/net/atom_network_delegate.h
View file

@ -79,15 +79,13 @@ class AtomNetworkDelegate : public net::NetworkDelegate {
URLPatterns patterns,
ResponseListener callback);
void SetDevToolsNetworkEmulationClientId(const std::string& client_id);
protected:
// net::NetworkDelegate:
int OnBeforeURLRequest(net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
GURL* new_url) override;
int OnBeforeStartTransaction(net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
net::HttpRequestHeaders* headers) override;
void OnBeforeSendHeaders(net::URLRequest* request,
const net::ProxyInfo& proxy_info,
@ -97,7 +95,7 @@ class AtomNetworkDelegate : public net::NetworkDelegate {
const net::HttpRequestHeaders& headers) override;
int OnHeadersReceived(
net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
const net::HttpResponseHeaders* original_response_headers,
scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
GURL* allowed_unsafe_redirect_url) override;
@ -108,14 +106,16 @@ class AtomNetworkDelegate : public net::NetworkDelegate {
int64_t bytes_read) override {}
void OnNetworkBytesSent(net::URLRequest* request,
int64_t bytes_sent) override {}
void OnCompleted(net::URLRequest* request, bool started) override;
void OnCompleted(net::URLRequest* request,
bool started,
int net_error) override;
void OnURLRequestDestroyed(net::URLRequest* request) override;
void OnPACScriptError(int line_number, const base::string16& error) override {
}
AuthRequiredResponse OnAuthRequired(
net::URLRequest* request,
const net::AuthChallengeInfo& auth_info,
const AuthCallback& callback,
AuthCallback callback,
net::AuthCredentials* credentials) override;
bool OnCanGetCookies(const net::URLRequest& request,
const net::CookieList& cookie_list) override;
@ -143,7 +143,7 @@ class AtomNetworkDelegate : public net::NetworkDelegate {
const GURL& endpoint) const override;
private:
void OnErrorOccurred(net::URLRequest* request, bool started);
void OnErrorOccurred(net::URLRequest* request, bool started, int net_error);
template <typename... Args>
void HandleSimpleEvent(SimpleEvent type,
@ -152,7 +152,7 @@ class AtomNetworkDelegate : public net::NetworkDelegate {
template <typename Out, typename... Args>
int HandleResponseEvent(ResponseEvent type,
net::URLRequest* request,
const net::CompletionCallback& callback,
net::CompletionOnceCallback callback,
Out out,
Args... args);
@ -169,12 +169,9 @@ class AtomNetworkDelegate : public net::NetworkDelegate {
std::map<uint64_t, scoped_refptr<LoginHandler>> login_handler_map_;
std::map<SimpleEvent, SimpleListenerInfo> simple_listeners_;
std::map<ResponseEvent, ResponseListenerInfo> response_listeners_;
std::map<uint64_t, net::CompletionCallback> callbacks_;
std::map<uint64_t, net::CompletionOnceCallback> callbacks_;
std::vector<std::string> ignore_connections_limit_domains_;
// Client id for devtools network emulation.
std::string client_id_;
DISALLOW_COPY_AND_ASSIGN(AtomNetworkDelegate);
};

3
atom/browser/net/atom_url_request.cc
View file

@ -267,7 +267,8 @@ void AtomURLRequest::DoCancel() {
void AtomURLRequest::DoFollowRedirect() {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (request_ && request_->is_redirecting() && redirect_policy_ == "manual") {
request_->FollowDeferredRedirect();
request_->FollowDeferredRedirect(
base::nullopt /* modified_request_headers */);
}
}

59
atom/browser/net/url_request_context_getter.cc
View file

@ -17,7 +17,6 @@
#include "atom/browser/net/atom_network_delegate.h"
#include "atom/browser/net/atom_url_request_job_factory.h"
#include "atom/browser/net/http_protocol_handler.h"
#include "atom/common/options_switches.h"
#include "base/command_line.h"
#include "base/strings/string_util.h"
#include "base/task_scheduler/post_task.h"
@ -83,7 +82,6 @@ network::mojom::NetworkContextParamsPtr CreateDefaultNetworkContextParams(
network_context_params->accept_language =
net::HttpUtil::GenerateAcceptLanguageHeader(
brightray::BrowserClient::Get()->GetApplicationLocale());
network_context_params->allow_gssapi_library_load = true;
network_context_params->enable_data_url_support = false;
network_context_params->proxy_resolver_factory =
ChromeMojoProxyResolverFactory::CreateWithStrongBinding().PassInterface();
@ -185,12 +183,6 @@ class ResourceContext : public content::ResourceContext {
ResourceContext() = default;
~ResourceContext() override = default;
net::HostResolver* GetHostResolver() override {
if (request_context_)
return request_context_->host_resolver();
return nullptr;
}
net::URLRequestContext* GetRequestContext() override {
return request_context_;
}
@ -226,8 +218,7 @@ URLRequestContextGetter::Handle::CreateMainRequestContextGetter(
DCHECK(!main_request_context_getter_.get());
LazyInitialize();
main_request_context_getter_ = new URLRequestContextGetter(
AtomBrowserClient::Get()->GetNetLog(), this, protocol_handlers,
std::move(protocol_interceptors));
this, protocol_handlers, std::move(protocol_interceptors));
return main_request_context_getter_;
}
@ -284,12 +275,10 @@ void URLRequestContextGetter::Handle::ShutdownOnUIThread() {
}
URLRequestContextGetter::URLRequestContextGetter(
net::NetLog* net_log,
URLRequestContextGetter::Handle* context_handle,
content::ProtocolHandlerMap* protocol_handlers,
content::URLRequestInterceptorScopedVector protocol_interceptors)
: net_log_(net_log),
context_handle_(context_handle),
: context_handle_(context_handle),
url_request_context_(nullptr),
protocol_interceptors_(std::move(protocol_interceptors)),
context_shutting_down_(false) {
@ -322,10 +311,11 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
return nullptr;
if (!url_request_context_) {
auto& command_line = *base::CommandLine::ForCurrentProcess();
std::unique_ptr<network::URLRequestContextBuilderMojo> builder =
std::make_unique<network::URLRequestContextBuilderMojo>();
builder->set_network_delegate(std::make_unique<AtomNetworkDelegate>());
auto network_delegate = std::make_unique<AtomNetworkDelegate>();
network_delegate_ = network_delegate.get();
builder->set_network_delegate(std::move(network_delegate));
ct_delegate_.reset(new brightray::RequireCTDelegate);
auto cert_verifier = std::make_unique<AtomCertVerifier>(ct_delegate_.get());
@ -334,42 +324,13 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
builder->SetCreateHttpTransactionFactoryCallback(
base::BindOnce(&content::CreateDevToolsNetworkTransactionFactory));
std::unique_ptr<net::HostResolver> host_resolver =
net::HostResolver::CreateDefaultResolver(net_log_);
// --host-resolver-rules
if (command_line.HasSwitch(network::switches::kHostResolverRules)) {
auto remapped_resolver =
std::make_unique<net::MappedHostResolver>(std::move(host_resolver));
remapped_resolver->SetRulesFromString(command_line.GetSwitchValueASCII(
network::switches::kHostResolverRules));
host_resolver = std::move(remapped_resolver);
}
net::HttpAuthPreferences auth_preferences;
// --auth-server-whitelist
if (command_line.HasSwitch(switches::kAuthServerWhitelist)) {
auth_preferences.SetServerWhitelist(
command_line.GetSwitchValueASCII(switches::kAuthServerWhitelist));
}
// --auth-negotiate-delegate-whitelist
if (command_line.HasSwitch(switches::kAuthNegotiateDelegateWhitelist)) {
auth_preferences.SetDelegateWhitelist(command_line.GetSwitchValueASCII(
switches::kAuthNegotiateDelegateWhitelist));
}
auto http_auth_handler_factory =
net::HttpAuthHandlerRegistryFactory::CreateDefault(host_resolver.get());
http_auth_handler_factory->SetHttpAuthPreferences(net::kNegotiateAuthScheme,
&auth_preferences);
builder->SetHttpAuthHandlerFactory(std::move(http_auth_handler_factory));
builder->set_host_resolver(std::move(host_resolver));
builder->set_ct_verifier(std::make_unique<net::MultiLogCTVerifier>());
network_context_ =
content::GetNetworkServiceImpl()->CreateNetworkContextWithBuilder(
std::move(context_handle_->main_network_context_request_),
std::move(context_handle_->main_network_context_params_),
std::move(builder), &url_request_context_);
auto* network_service = content::GetNetworkServiceImpl();
network_context_ = network_service->CreateNetworkContextWithBuilder(
std::move(context_handle_->main_network_context_request_),
std::move(context_handle_->main_network_context_params_),
std::move(builder), &url_request_context_);
net::TransportSecurityState* transport_security_state =
url_request_context_->transport_security_state();

10
atom/browser/net/url_request_context_getter.h
View file

@ -23,13 +23,10 @@ namespace brightray {
class RequireCTDelegate;
} // namespace brightray
namespace net {
class NetLog;
}
namespace atom {
class AtomBrowserContext;
class AtomNetworkDelegate;
class AtomURLRequestJobFactory;
class ResourceContext;
@ -48,6 +45,8 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
return top_job_factory_.get();
}
AtomNetworkDelegate* network_delegate() const { return network_delegate_; }
private:
friend class AtomBrowserContext;
@ -88,7 +87,6 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
};
URLRequestContextGetter(
net::NetLog* net_log,
URLRequestContextGetter::Handle* context_handle,
content::ProtocolHandlerMap* protocol_handlers,
content::URLRequestInterceptorScopedVector protocol_interceptors);
@ -102,9 +100,9 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
std::unique_ptr<AtomURLRequestJobFactory> top_job_factory_;
std::unique_ptr<network::mojom::NetworkContext> network_context_;
net::NetLog* net_log_;
URLRequestContextGetter::Handle* context_handle_;
net::URLRequestContext* url_request_context_;
AtomNetworkDelegate* network_delegate_;
content::ProtocolHandlerMap protocol_handlers_;
content::URLRequestInterceptorScopedVector protocol_interceptors_;
bool context_shutting_down_;

4
atom/browser/special_storage_policy.cc
View file

@ -37,9 +37,9 @@ bool SpecialStoragePolicy::HasSessionOnlyOrigins() {
return false;
}
storage::SpecialStoragePolicy::DeleteCookiePredicate
network::SessionCleanupCookieStore::DeleteCookiePredicate
SpecialStoragePolicy::CreateDeleteCookieOnExitPredicate() {
return storage::SpecialStoragePolicy::DeleteCookiePredicate();
return network::SessionCleanupCookieStore::DeleteCookiePredicate();
}
} // namespace atom

2
atom/browser/special_storage_policy.h
View file

@ -20,7 +20,7 @@ class SpecialStoragePolicy : public storage::SpecialStoragePolicy {
bool HasIsolatedStorage(const GURL& origin) override;
bool IsStorageSessionOnly(const GURL& origin) override;
bool HasSessionOnlyOrigins() override;
storage::SpecialStoragePolicy::DeleteCookiePredicate
network::SessionCleanupCookieStore::DeleteCookiePredicate
CreateDeleteCookieOnExitPredicate() override;
protected:

1
atom/browser/ui/accelerator_util.cc
View file

@ -64,7 +64,6 @@ bool StringToAccelerator(const std::string& shortcut,
}
*accelerator = ui::Accelerator(key, modifiers);
SetPlatformAccelerator(accelerator);
return true;
}

3
atom/browser/ui/accelerator_util.h
View file

@ -23,9 +23,6 @@ typedef std::map<ui::Accelerator, MenuItem> AcceleratorTable;
bool StringToAccelerator(const std::string& description,
ui::Accelerator* accelerator);
// Set platform accelerator for the Accelerator.
void SetPlatformAccelerator(ui::Accelerator* accelerator);
// Generate a table that contains memu model's accelerators and command ids.
void GenerateAcceleratorTable(AcceleratorTable* table,
atom::AtomMenuModel* model);

46
atom/browser/ui/accelerator_util_mac.mm
View file

@ -1,46 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/ui/accelerator_util.h"
#include "ui/base/accelerators/accelerator.h"
#import "ui/base/accelerators/platform_accelerator_cocoa.h"
#import "ui/events/keycodes/keyboard_code_conversion_mac.h"
namespace accelerator_util {
void SetPlatformAccelerator(ui::Accelerator* accelerator) {
unichar character;
unichar characterIgnoringModifiers;
NSUInteger modifiers = (accelerator->IsCtrlDown() ? NSControlKeyMask : 0) |
(accelerator->IsCmdDown() ? NSCommandKeyMask : 0) |
(accelerator->IsAltDown() ? NSAlternateKeyMask : 0) |
(accelerator->IsShiftDown() ? NSShiftKeyMask : 0);
ui::MacKeyCodeForWindowsKeyCode(accelerator->key_code(), modifiers,
&character, &characterIgnoringModifiers);
if (character != characterIgnoringModifiers) {
if (isdigit(characterIgnoringModifiers)) {
// The character is a number so lets not mutate it with the modifiers
character = characterIgnoringModifiers;
} else {
modifiers ^= NSShiftKeyMask;
}
}
if (character == NSDeleteFunctionKey) {
character = NSDeleteCharacter;
}
NSString* characters =
[[[NSString alloc] initWithCharacters:&character length:1] autorelease];
std::unique_ptr<ui::PlatformAccelerator> platform_accelerator(
new ui::PlatformAcceleratorCocoa(characters, modifiers));
accelerator->set_platform_accelerator(std::move(platform_accelerator));
}
} // namespace accelerator_util

13
atom/browser/ui/accelerator_util_views.cc
View file

@ -1,13 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/ui/accelerator_util.h"
#include "ui/base/accelerators/accelerator.h"
namespace accelerator_util {
void SetPlatformAccelerator(ui::Accelerator* accelerator) {}
} // namespace accelerator_util

14
atom/browser/ui/cocoa/atom_menu_controller.mm
View file

@ -239,14 +239,12 @@ static base::scoped_nsobject<NSMenu> recentDocumentsMenuSwap_;
ui::Accelerator accelerator;
if (model->GetAcceleratorAtWithParams(index, useDefaultAccelerator_,
&accelerator)) {
const ui::PlatformAcceleratorCocoa* platformAccelerator =
static_cast<const ui::PlatformAcceleratorCocoa*>(
accelerator.platform_accelerator());
if (platformAccelerator) {
[item setKeyEquivalent:platformAccelerator->characters()];
[item
setKeyEquivalentModifierMask:platformAccelerator->modifier_mask()];
}
NSString* key_equivalent;
NSUInteger modifier_mask;
GetKeyEquivalentAndModifierMaskFromAccelerator(
accelerator, &key_equivalent, &modifier_mask);
[item setKeyEquivalent:key_equivalent];
[item setKeyEquivalentModifierMask:modifier_mask];
}
// Set menu item's role.

22
atom/browser/web_contents_permission_helper.cc
View file

@ -36,9 +36,10 @@ namespace atom {
namespace {
void MediaAccessAllowed(const content::MediaStreamRequest& request,
const content::MediaResponseCallback& callback,
content::MediaResponseCallback callback,
bool allowed) {
brightray::MediaStreamDevicesController controller(request, callback);
brightray::MediaStreamDevicesController controller(request,
std::move(callback));
if (allowed)
controller.TakeAction();
else
@ -50,7 +51,7 @@ void OnPointerLockResponse(content::WebContents* web_contents, bool allowed) {
web_contents->GotResponseToLockMouseRequest(allowed);
}
void OnPermissionResponse(const base::Callback<void(bool)>& callback,
void OnPermissionResponse(base::Callback<void(bool)> callback,
blink::mojom::PermissionStatus status) {
if (status == blink::mojom::PermissionStatus::GRANTED)
callback.Run(true);
@ -73,11 +74,11 @@ void WebContentsPermissionHelper::RequestPermission(
const base::DictionaryValue* details) {
auto* rfh = web_contents_->GetMainFrame();
auto* permission_manager = static_cast<AtomPermissionManager*>(
web_contents_->GetBrowserContext()->GetPermissionManager());
web_contents_->GetBrowserContext()->GetPermissionControllerDelegate());
auto origin = web_contents_->GetLastCommittedURL();
permission_manager->RequestPermissionWithDetails(
permission, rfh, origin, false, details,
base::Bind(&OnPermissionResponse, callback));
base::Bind(&OnPermissionResponse, std::move(callback)));
}
bool WebContentsPermissionHelper::CheckPermission(
@ -85,7 +86,7 @@ bool WebContentsPermissionHelper::CheckPermission(
const base::DictionaryValue* details) const {
auto* rfh = web_contents_->GetMainFrame();
auto* permission_manager = static_cast<AtomPermissionManager*>(
web_contents_->GetBrowserContext()->GetPermissionManager());
web_contents_->GetBrowserContext()->GetPermissionControllerDelegate());
auto origin = web_contents_->GetLastCommittedURL();
return permission_manager->CheckPermissionWithDetails(permission, rfh, origin,
details);
@ -100,8 +101,9 @@ void WebContentsPermissionHelper::RequestFullscreenPermission(
void WebContentsPermissionHelper::RequestMediaAccessPermission(
const content::MediaStreamRequest& request,
const content::MediaResponseCallback& response_callback) {
auto callback = base::Bind(&MediaAccessAllowed, request, response_callback);
content::MediaResponseCallback response_callback) {
auto callback = base::AdaptCallbackForRepeating(base::BindOnce(
&MediaAccessAllowed, request, std::move(response_callback)));
base::DictionaryValue details;
std::unique_ptr<base::ListValue> media_types(new base::ListValue);
@ -117,8 +119,8 @@ void WebContentsPermissionHelper::RequestMediaAccessPermission(
// The permission type doesn't matter here, AUDIO_CAPTURE/VIDEO_CAPTURE
// are presented as same type in content_converter.h.
RequestPermission(content::PermissionType::AUDIO_CAPTURE, callback, false,
&details);
RequestPermission(content::PermissionType::AUDIO_CAPTURE, std::move(callback),
false, &details);
}
void WebContentsPermissionHelper::RequestWebNotificationPermission(

2
atom/browser/web_contents_permission_helper.h
View file

@ -27,7 +27,7 @@ class WebContentsPermissionHelper
void RequestFullscreenPermission(const base::Callback<void(bool)>& callback);
void RequestMediaAccessPermission(
const content::MediaStreamRequest& request,
const content::MediaResponseCallback& callback);
content::MediaResponseCallback callback);
void RequestWebNotificationPermission(
const base::Callback<void(bool)>& callback);
void RequestPointerLockPermission(bool user_gesture);

2
atom/browser/web_contents_preferences.cc
View file

@ -329,7 +329,7 @@ void WebContentsPreferences::AppendCommandLineSwitches(
if (embedder) {
auto* relay = NativeWindowRelay::FromWebContents(embedder);
if (relay) {
auto* window = relay->window.get();
auto* window = relay->GetNativeWindow();
if (window) {
const bool visible = window->IsVisible() && !window->IsMinimized();
if (!visible) {