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

fix: switch to mojo proxy resolver (3-1-x) (#15813)

Browse source
This commit is contained in:
Robo 2018-11-27 05:08:33 +05:30 • committed by Michelle Tilley
parent d5a6bb665b
commit 4abf55801f
65 changed files with 1838 additions and 1797 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -69,7 +69,7 @@ scoped_refptr<AtomURLRequest> AtomURLRequest::Create(
if (!browser_context || url.empty() || !delegate) {
return nullptr;
}
scoped_refptr<brightray::URLRequestContextGetter> request_context_getter(
scoped_refptr<net::URLRequestContextGetter> request_context_getter(
browser_context->GetRequestContext());
DCHECK(request_context_getter);
scoped_refptr<AtomURLRequest> atom_url_request(new AtomURLRequest(delegate));

29
atom/browser/net/atom_url_request_job_factory.cc
View file

@ -5,6 +5,8 @@
#include "atom/browser/net/atom_url_request_job_factory.h"
#include <utility>
#include "base/memory/ptr_util.h"
#include "base/stl_util.h"
#include "content/public/browser/browser_thread.h"
@ -33,6 +35,11 @@ AtomURLRequestJobFactory::~AtomURLRequestJobFactory() {
Clear();
}
void AtomURLRequestJobFactory::Chain(
std::unique_ptr<net::URLRequestJobFactory> job_factory) {
job_factory_ = std::move(job_factory);
}
bool AtomURLRequestJobFactory::SetProtocolHandler(
const std::string& scheme,
std::unique_ptr<ProtocolHandler> protocol_handler) {
@ -73,16 +80,6 @@ bool AtomURLRequestJobFactory::UninterceptProtocol(const std::string& scheme) {
return true;
}
ProtocolHandler* AtomURLRequestJobFactory::GetProtocolHandler(
const std::string& scheme) const {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
auto it = protocol_handler_map_.find(scheme);
if (it == protocol_handler_map_.end())
return nullptr;
return it->second;
}
bool AtomURLRequestJobFactory::HasProtocolHandler(
const std::string& scheme) const {
return base::ContainsKey(protocol_handler_map_, scheme);
@ -101,11 +98,18 @@ net::URLRequestJob* AtomURLRequestJobFactory::MaybeCreateJobWithProtocolHandler(
net::NetworkDelegate* network_delegate) const {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
auto* job = job_factory_->MaybeCreateJobWithProtocolHandler(scheme, request,
network_delegate);
if (job)
return job;
auto it = protocol_handler_map_.find(scheme);
if (it == protocol_handler_map_.end())
return nullptr;
if (request->GetUserData(DisableProtocolInterceptFlagKey()))
return nullptr;
return it->second->MaybeCreateJob(request, network_delegate);
}
@ -113,13 +117,14 @@ net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptRedirect(
net::URLRequest* request,
net::NetworkDelegate* network_delegate,
const GURL& location) const {
return nullptr;
return job_factory_->MaybeInterceptRedirect(request, network_delegate,
location);
}
net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptResponse(
net::URLRequest* request,
net::NetworkDelegate* network_delegate) const {
return nullptr;
return job_factory_->MaybeInterceptResponse(request, network_delegate);
}
bool AtomURLRequestJobFactory::IsHandledProtocol(

8
atom/browser/net/atom_url_request_job_factory.h
View file

@ -23,6 +23,9 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
AtomURLRequestJobFactory();
~AtomURLRequestJobFactory() override;
// Requests are forwarded to the chained job factory first.
void Chain(std::unique_ptr<net::URLRequestJobFactory> job_factory);
// Sets the ProtocolHandler for a scheme. Returns true on success, false on
// failure (a ProtocolHandler already exists for |scheme|). On success,
// URLRequestJobFactory takes ownership of |protocol_handler|.
@ -34,9 +37,6 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
std::unique_ptr<ProtocolHandler> protocol_handler);
bool UninterceptProtocol(const std::string& scheme);
// Returns the protocol handler registered with scheme.
ProtocolHandler* GetProtocolHandler(const std::string& scheme) const;
// Whether the protocol handler is registered by the job factory.
bool HasProtocolHandler(const std::string& scheme) const;
@ -69,6 +69,8 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
// Can only be accessed in IO thread.
OriginalProtocolsMap original_protocols_;
std::unique_ptr<net::URLRequestJobFactory> job_factory_;
DISALLOW_COPY_AND_ASSIGN(AtomURLRequestJobFactory);
};

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

@ -6,7 +6,11 @@
#define ATOM_BROWSER_NET_COOKIE_DETAILS_H_
#include "base/macros.h"
#include "net/cookies/cookie_change_dispatcher.h"
#include "services/network/public/mojom/cookie_manager.mojom.h"
namespace net {
class CanonicalCookie;
}
namespace atom {
@ -14,12 +18,12 @@ struct CookieDetails {
public:
CookieDetails(const net::CanonicalCookie* cookie_copy,
bool is_removed,
net::CookieChangeCause cause)
network::mojom::CookieChangeCause cause)
: cookie(cookie_copy), removed(is_removed), cause(cause) {}
const net::CanonicalCookie* cookie;
bool removed;
net::CookieChangeCause cause;
network::mojom::CookieChangeCause cause;
};
} // namespace atom

87
atom/browser/net/resolve_proxy_helper.cc Normal file
View file

@ -0,0 +1,87 @@
// Copyright (c) 2018 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/net/resolve_proxy_helper.h"
#include "atom/browser/atom_browser_context.h"
#include "base/bind.h"
#include "base/threading/thread_task_runner_handle.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
namespace atom {
ResolveProxyHelper::ResolveProxyHelper(AtomBrowserContext* browser_context)
: context_getter_(browser_context->GetRequestContext()),
original_thread_(base::ThreadTaskRunnerHandle::Get()) {}
ResolveProxyHelper::~ResolveProxyHelper() {
// Clear all pending requests if the ProxyService is still alive.
pending_requests_.clear();
}
void ResolveProxyHelper::ResolveProxy(const GURL& url,
const ResolveProxyCallback& callback) {
// Enqueue the pending request.
pending_requests_.push_back(PendingRequest(url, callback));
// If nothing is in progress, start.
if (pending_requests_.size() == 1)
StartPendingRequest();
}
void ResolveProxyHelper::StartPendingRequest() {
auto& pending_request = pending_requests_.front();
context_getter_->GetNetworkTaskRunner()->PostTask(
FROM_HERE, base::BindOnce(&ResolveProxyHelper::StartPendingRequestInIO,
base::Unretained(this), pending_request.url));
}
void ResolveProxyHelper::StartPendingRequestInIO(const GURL& url) {
auto* proxy_service =
context_getter_->GetURLRequestContext()->proxy_resolution_service();
// Start the request.
int result = proxy_service->ResolveProxy(
url, std::string(), &proxy_info_,
base::Bind(&ResolveProxyHelper::OnProxyResolveComplete,
base::RetainedRef(this)),
nullptr, nullptr, net::NetLogWithSource());
// Completed synchronously.
if (result != net::ERR_IO_PENDING)
OnProxyResolveComplete(result);
}
void ResolveProxyHelper::OnProxyResolveComplete(int result) {
DCHECK(!pending_requests_.empty());
std::string proxy;
if (result == net::OK)
proxy = proxy_info_.ToPacString();
original_thread_->PostTask(
FROM_HERE, base::BindOnce(&ResolveProxyHelper::SendProxyResult,
base::RetainedRef(this), proxy));
}
void ResolveProxyHelper::SendProxyResult(const std::string& proxy) {
DCHECK(!pending_requests_.empty());
const auto& completed_request = pending_requests_.front();
if (!completed_request.callback.is_null())
completed_request.callback.Run(proxy);
// Clear the current (completed) request.
pending_requests_.pop_front();
// Start the next request.
if (!pending_requests_.empty())
StartPendingRequest();
}
ResolveProxyHelper::PendingRequest::PendingRequest(
const GURL& url,
const ResolveProxyCallback& callback)
: url(url), callback(callback) {}
} // namespace atom

61
atom/browser/net/resolve_proxy_helper.h Normal file
View file

@ -0,0 +1,61 @@
// Copyright (c) 2018 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef ATOM_BROWSER_NET_RESOLVE_PROXY_HELPER_H_
#define ATOM_BROWSER_NET_RESOLVE_PROXY_HELPER_H_
#include <deque>
#include <string>
#include "base/memory/ref_counted.h"
#include "net/proxy_resolution/proxy_service.h"
#include "url/gurl.h"
namespace net {
class URLRequestContextGetter;
}
namespace atom {
class AtomBrowserContext;
class ResolveProxyHelper
: public base::RefCountedThreadSafe<ResolveProxyHelper> {
public:
using ResolveProxyCallback = base::Callback<void(std::string)>;
explicit ResolveProxyHelper(AtomBrowserContext* browser_context);
void ResolveProxy(const GURL& url, const ResolveProxyCallback& callback);
private:
friend class base::RefCountedThreadSafe<ResolveProxyHelper>;
// A PendingRequest is a resolve request that is in progress, or queued.
struct PendingRequest {
public:
PendingRequest(const GURL& url, const ResolveProxyCallback& callback);
GURL url;
ResolveProxyCallback callback;
};
~ResolveProxyHelper();
// Starts the first pending request.
void StartPendingRequest();
void StartPendingRequestInIO(const GURL& url);
void OnProxyResolveComplete(int result);
void SendProxyResult(const std::string& proxy);
net::ProxyInfo proxy_info_;
std::deque<PendingRequest> pending_requests_;
scoped_refptr<net::URLRequestContextGetter> context_getter_;
scoped_refptr<base::SingleThreadTaskRunner> original_thread_;
DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
};
} // namespace atom
#endif // ATOM_BROWSER_NET_RESOLVE_PROXY_HELPER_H_

413
atom/browser/net/url_request_context_getter.cc Normal file
View file

@ -0,0 +1,413 @@
// Copyright (c) 2018 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/net/url_request_context_getter.h"
#include <algorithm>
#include <memory>
#include <utility>
#include "atom/browser/api/atom_api_protocol.h"
#include "atom/browser/atom_browser_client.h"
#include "atom/browser/atom_browser_context.h"
#include "atom/browser/net/about_protocol_handler.h"
#include "atom/browser/net/asar/asar_protocol_handler.h"
#include "atom/browser/net/atom_cert_verifier.h"
#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"
#include "brightray/browser/net/require_ct_delegate.h"
#include "chrome/browser/net/chrome_mojo_proxy_resolver_factory.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "components/network_session_configurator/common/network_switches.h"
#include "components/prefs/value_map_pref_store.h"
#include "components/proxy_config/proxy_config_dictionary.h"
#include "components/proxy_config/proxy_config_pref_names.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/devtools_network_transaction_factory.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/resource_context.h"
#include "content/public/common/content_switches.h"
#include "net/base/host_mapping_rules.h"
#include "net/cert/multi_log_ct_verifier.h"
#include "net/cookies/cookie_monster.h"
#include "net/dns/mapped_host_resolver.h"
#include "net/http/http_auth_handler_factory.h"
#include "net/http/http_auth_preferences.h"
#include "net/http/http_auth_scheme.h"
#include "net/http/http_transaction_factory.h"
#include "net/log/net_log.h"
#include "net/proxy_resolution/proxy_config.h"
#include "net/proxy_resolution/proxy_config_service.h"
#include "net/proxy_resolution/proxy_service.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/url_request/data_protocol_handler.h"
#include "net/url_request/static_http_user_agent_settings.h"
#include "net/url_request/url_request_intercepting_job_factory.h"
#include "net/url_request/url_request_job_factory_impl.h"
#include "services/network/ignore_errors_cert_verifier.h"
#include "services/network/network_service.h"
#include "services/network/public/cpp/network_switches.h"
#include "services/network/url_request_context_builder_mojo.h"
#include "url/url_constants.h"
#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
#include "net/url_request/ftp_protocol_handler.h"
#endif
using content::BrowserThread;
namespace atom {
namespace {
network::mojom::NetworkContextParamsPtr CreateDefaultNetworkContextParams(
const base::FilePath& base_path,
const std::string& user_agent,
bool in_memory,
bool use_cache,
int max_cache_size) {
network::mojom::NetworkContextParamsPtr network_context_params =
network::mojom::NetworkContextParams::New();
network_context_params->enable_brotli = true;
network_context_params->user_agent = user_agent;
network_context_params->http_cache_enabled = use_cache;
network_context_params->enable_data_url_support = false;
network_context_params->proxy_resolver_factory =
ChromeMojoProxyResolverFactory::CreateWithStrongBinding().PassInterface();
if (!in_memory) {
network_context_params->http_cache_path =
base_path.Append(chrome::kCacheDirname);
network_context_params->http_cache_max_size = max_cache_size;
network_context_params->http_server_properties_path =
base_path.Append(chrome::kNetworkPersistentStateFilename);
network_context_params->cookie_path =
base_path.Append(chrome::kCookieFilename);
network_context_params->channel_id_path =
base_path.Append(chrome::kChannelIDFilename);
network_context_params->restore_old_session_cookies = false;
network_context_params->persist_session_cookies = false;
}
// TODO(deepak1556): Decide the stand on chrome ct policy and
// enable it.
// See //net/docs/certificate-transparency.md
// network_context_params->enforce_chrome_ct_policy = true;
return network_context_params;
}
void SetupAtomURLRequestJobFactory(
content::ProtocolHandlerMap* protocol_handlers,
net::URLRequestContext* url_request_context,
AtomURLRequestJobFactory* job_factory) {
for (auto& protocol_handler : *protocol_handlers) {
job_factory->SetProtocolHandler(
protocol_handler.first,
base::WrapUnique(protocol_handler.second.release()));
}
protocol_handlers->clear();
job_factory->SetProtocolHandler(url::kAboutScheme,
std::make_unique<AboutProtocolHandler>());
job_factory->SetProtocolHandler(url::kDataScheme,
std::make_unique<net::DataProtocolHandler>());
job_factory->SetProtocolHandler(
url::kFileScheme,
std::make_unique<asar::AsarProtocolHandler>(
base::CreateTaskRunnerWithTraits(
{base::MayBlock(), base::TaskPriority::USER_BLOCKING,
base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));
job_factory->SetProtocolHandler(
url::kHttpScheme,
std::make_unique<HttpProtocolHandler>(url::kHttpScheme));
job_factory->SetProtocolHandler(
url::kHttpsScheme,
std::make_unique<HttpProtocolHandler>(url::kHttpsScheme));
job_factory->SetProtocolHandler(
url::kWsScheme, std::make_unique<HttpProtocolHandler>(url::kWsScheme));
job_factory->SetProtocolHandler(
url::kWssScheme, std::make_unique<HttpProtocolHandler>(url::kWssScheme));
#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
auto* host_resolver = url_request_context->host_resolver();
job_factory->SetProtocolHandler(
url::kFtpScheme, net::FtpProtocolHandler::Create(host_resolver));
#endif
}
void ApplyProxyModeFromCommandLine(ValueMapPrefStore* pref_store) {
if (!pref_store)
return;
auto* command_line = base::CommandLine::ForCurrentProcess();
if (command_line->HasSwitch(::switches::kNoProxyServer)) {
pref_store->SetValue(proxy_config::prefs::kProxy,
ProxyConfigDictionary::CreateDirect(),
WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
} else if (command_line->HasSwitch(::switches::kProxyPacUrl)) {
std::string pac_script_url =
command_line->GetSwitchValueASCII(::switches::kProxyPacUrl);
pref_store->SetValue(proxy_config::prefs::kProxy,
ProxyConfigDictionary::CreatePacScript(
pac_script_url, false /* pac_mandatory */),
WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
} else if (command_line->HasSwitch(::switches::kProxyAutoDetect)) {
pref_store->SetValue(proxy_config::prefs::kProxy,
ProxyConfigDictionary::CreateAutoDetect(),
WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
} else if (command_line->HasSwitch(::switches::kProxyServer)) {
std::string proxy_server =
command_line->GetSwitchValueASCII(::switches::kProxyServer);
std::string bypass_list =
command_line->GetSwitchValueASCII(::switches::kProxyBypassList);
pref_store->SetValue(
proxy_config::prefs::kProxy,
ProxyConfigDictionary::CreateFixedServers(proxy_server, bypass_list),
WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
}
}
} // namespace
class ResourceContext : public content::ResourceContext {
public:
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_;
}
private:
friend class URLRequestContextGetter;
net::URLRequestContext* request_context_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ResourceContext);
};
URLRequestContextGetter::Handle::Handle(
base::WeakPtr<AtomBrowserContext> browser_context)
: resource_context_(new ResourceContext),
browser_context_(browser_context),
initialized_(false) {}
URLRequestContextGetter::Handle::~Handle() {}
content::ResourceContext*
URLRequestContextGetter::Handle::GetResourceContext() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
LazyInitialize();
return resource_context_.get();
}
scoped_refptr<URLRequestContextGetter>
URLRequestContextGetter::Handle::CreateMainRequestContextGetter(
content::ProtocolHandlerMap* protocol_handlers,
content::URLRequestInterceptorScopedVector protocol_interceptors) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK(!main_request_context_getter_.get());
LazyInitialize();
main_request_context_getter_ = new URLRequestContextGetter(
AtomBrowserClient::Get()->GetNetLog(), this, protocol_handlers,
std::move(protocol_interceptors));
return main_request_context_getter_;
}
scoped_refptr<URLRequestContextGetter>
URLRequestContextGetter::Handle::GetMainRequestContextGetter() {
return main_request_context_getter_;
}
network::mojom::NetworkContextPtr
URLRequestContextGetter::Handle::GetNetworkContext() {
if (!main_network_context_) {
main_network_context_request_ = mojo::MakeRequest(&main_network_context_);
}
return std::move(main_network_context_);
}
void URLRequestContextGetter::Handle::LazyInitialize() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (initialized_)
return;
initialized_ = true;
main_network_context_params_ = CreateDefaultNetworkContextParams(
browser_context_->GetPath(), browser_context_->GetUserAgent(),
browser_context_->IsOffTheRecord(), browser_context_->CanUseHttpCache(),
browser_context_->GetMaxCacheSize());
browser_context_->proxy_config_monitor()->AddToNetworkContextParams(
main_network_context_params_.get());
ApplyProxyModeFromCommandLine(browser_context_->in_memory_pref_store());
if (!main_network_context_request_.is_pending()) {
main_network_context_request_ = mojo::MakeRequest(&main_network_context_);
}
content::BrowserContext::EnsureResourceContextInitialized(
browser_context_.get());
}
void URLRequestContextGetter::Handle::ShutdownOnUIThread() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (main_request_context_getter_.get()) {
if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::BindOnce(&URLRequestContextGetter::NotifyContextShuttingDown,
base::RetainedRef(main_request_context_getter_),
std::move(resource_context_)));
}
}
if (!BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this))
delete this;
}
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),
url_request_context_(nullptr),
protocol_interceptors_(std::move(protocol_interceptors)),
context_shutting_down_(false) {
// Must first be created on the UI thread.
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (protocol_handlers)
std::swap(protocol_handlers_, *protocol_handlers);
}
URLRequestContextGetter::~URLRequestContextGetter() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
// NotifyContextShuttingDown should have been called.
DCHECK(context_shutting_down_);
}
void URLRequestContextGetter::NotifyContextShuttingDown(
std::unique_ptr<ResourceContext> resource_context) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
context_shutting_down_ = true;
resource_context.reset();
net::URLRequestContextGetter::NotifyContextShuttingDown();
}
net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (context_shutting_down_)
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>());
ct_delegate_.reset(new brightray::RequireCTDelegate);
auto cert_verifier = std::make_unique<AtomCertVerifier>(ct_delegate_.get());
builder->SetCertVerifier(std::move(cert_verifier));
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_);
net::TransportSecurityState* transport_security_state =
url_request_context_->transport_security_state();
transport_security_state->SetRequireCTDelegate(ct_delegate_.get());
// Add custom standard schemes to cookie schemes.
auto* cookie_monster =
static_cast<net::CookieMonster*>(url_request_context_->cookie_store());
std::vector<std::string> cookie_schemes(
{url::kHttpScheme, url::kHttpsScheme, url::kWsScheme, url::kWssScheme});
const auto& custom_standard_schemes = atom::api::GetStandardSchemes();
cookie_schemes.insert(cookie_schemes.end(), custom_standard_schemes.begin(),
custom_standard_schemes.end());
cookie_monster->SetCookieableSchemes(cookie_schemes);
// Setup handlers for custom job factory.
top_job_factory_.reset(new AtomURLRequestJobFactory);
SetupAtomURLRequestJobFactory(&protocol_handlers_, url_request_context_,
top_job_factory_.get());
std::unique_ptr<net::URLRequestJobFactory> inner_job_factory(
new net::URLRequestJobFactoryImpl);
if (!protocol_interceptors_.empty()) {
// Set up interceptors in the reverse order.
for (auto it = protocol_interceptors_.rbegin();
it != protocol_interceptors_.rend(); ++it) {
inner_job_factory.reset(new net::URLRequestInterceptingJobFactory(
std::move(inner_job_factory), std::move(*it)));
}
protocol_interceptors_.clear();
}
top_job_factory_->Chain(std::move(inner_job_factory));
url_request_context_->set_job_factory(top_job_factory_.get());
context_handle_->resource_context_->request_context_ = url_request_context_;
}
return url_request_context_;
}
scoped_refptr<base::SingleThreadTaskRunner>
URLRequestContextGetter::GetNetworkTaskRunner() const {
return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
}
} // namespace atom

117
atom/browser/net/url_request_context_getter.h Normal file
View file

@ -0,0 +1,117 @@
// Copyright (c) 2018 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef ATOM_BROWSER_NET_URL_REQUEST_CONTEXT_GETTER_H_
#define ATOM_BROWSER_NET_URL_REQUEST_CONTEXT_GETTER_H_
#include <memory>
#include <string>
#include <vector>
#include "base/files/file_path.h"
#include "content/public/browser/browser_context.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "services/network/public/mojom/network_service.mojom.h"
#if DCHECK_IS_ON()
#include "base/debug/leak_tracker.h"
#endif
namespace brightray {
class RequireCTDelegate;
} // namespace brightray
namespace net {
class NetLog;
}
namespace atom {
class AtomBrowserContext;
class AtomURLRequestJobFactory;
class ResourceContext;
class URLRequestContextGetter : public net::URLRequestContextGetter {
public:
// net::URLRequestContextGetter:
net::URLRequestContext* GetURLRequestContext() override;
scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
const override;
// Discard reference to URLRequestContext and inform observers to
// shutdown. Must be called only on IO thread.
void NotifyContextShuttingDown(std::unique_ptr<ResourceContext>);
AtomURLRequestJobFactory* job_factory() const {
return top_job_factory_.get();
}
private:
friend class AtomBrowserContext;
// Responsible for destroying URLRequestContextGetter
// on the IO thread.
class Handle {
public:
explicit Handle(base::WeakPtr<AtomBrowserContext> browser_context);
~Handle();
scoped_refptr<URLRequestContextGetter> CreateMainRequestContextGetter(
content::ProtocolHandlerMap* protocol_handlers,
content::URLRequestInterceptorScopedVector protocol_interceptors);
content::ResourceContext* GetResourceContext();
scoped_refptr<URLRequestContextGetter> GetMainRequestContextGetter();
network::mojom::NetworkContextPtr GetNetworkContext();
void ShutdownOnUIThread();
private:
friend class URLRequestContextGetter;
void LazyInitialize();
scoped_refptr<URLRequestContextGetter> main_request_context_getter_;
std::unique_ptr<ResourceContext> resource_context_;
base::WeakPtr<AtomBrowserContext> browser_context_;
// This is a NetworkContext interface that uses URLRequestContextGetter
// NetworkContext, ownership is passed to StoragePartition when
// CreateMainNetworkContext is called.
network::mojom::NetworkContextPtr main_network_context_;
// Request corresponding to |main_network_context_|. Ownership
// is passed to network service.
network::mojom::NetworkContextRequest main_network_context_request_;
network::mojom::NetworkContextParamsPtr main_network_context_params_;
bool initialized_;
DISALLOW_COPY_AND_ASSIGN(Handle);
};
URLRequestContextGetter(
net::NetLog* net_log,
URLRequestContextGetter::Handle* context_handle,
content::ProtocolHandlerMap* protocol_handlers,
content::URLRequestInterceptorScopedVector protocol_interceptors);
~URLRequestContextGetter() override;
#if DCHECK_IS_ON()
base::debug::LeakTracker<URLRequestContextGetter> leak_tracker_;
#endif
std::unique_ptr<brightray::RequireCTDelegate> ct_delegate_;
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_;
content::ProtocolHandlerMap protocol_handlers_;
content::URLRequestInterceptorScopedVector protocol_interceptors_;
bool context_shutting_down_;
DISALLOW_COPY_AND_ASSIGN(URLRequestContextGetter);
};
} // namespace atom
#endif // ATOM_BROWSER_NET_URL_REQUEST_CONTEXT_GETTER_H_

4
atom/browser/net/url_request_fetch_job.cc
View file

@ -167,6 +167,9 @@ void URLRequestFetchJob::StartAsync(std::unique_ptr<base::Value> options) {
request()->extra_request_headers().ToString());
fetcher_->Start();
// URLFetcher has a refernce to the context, which
// will be cleared when the request is destroyed.
url_request_context_getter_ = nullptr;
}
void URLRequestFetchJob::HeadersCompleted() {
@ -199,6 +202,7 @@ int URLRequestFetchJob::DataAvailable(net::IOBuffer* buffer,
void URLRequestFetchJob::Kill() {
JsAsker<URLRequestJob>::Kill();
fetcher_.reset();
custom_browser_context_ = nullptr;
}
int URLRequestFetchJob::ReadRawData(net::IOBuffer* dest, int dest_size) {