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

Merge pull request #11459 from electron/upgrade-to-chromium-63

Browse source 
Upgrade to Chromium 63
This commit is contained in:
Cheng Zhao 2018-03-20 17:25:34 +09:00 committed by GitHub
commit cd30a4e2d4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
121 changed files with 722 additions and 2087 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
atom/app/atom_content_client.cc
View file

@ -7,7 +7,6 @@
#include <string>
#include <vector>
#include "atom/common/atom_constants.h"
#include "atom/common/atom_version.h"
#include "atom/common/chrome_version.h"
#include "atom/common/options_switches.h"
@ -20,7 +19,6 @@
#include "content/public/common/pepper_plugin_info.h"
#include "content/public/common/user_agent.h"
#include "media/media_features.h"
#include "pdf/pdf.h"
#include "ppapi/shared_impl/ppapi_permissions.h"
#include "third_party/widevine/cdm/stub/widevine_cdm_version.h"
#include "ui/base/l10n/l10n_util.h"
@ -30,6 +28,11 @@
#include "chrome/common/widevine_cdm_constants.h"
#endif
#if defined(ENABLE_PDF_VIEWER)
#include "atom/common/atom_constants.h"
#include "pdf/pdf.h"
#endif // defined(ENABLE_PDF_VIEWER)
namespace atom {
namespace {
@ -111,6 +114,7 @@ content::PepperPluginInfo CreateWidevineCdmInfo(const base::FilePath& path,
}
#endif // defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_LIBRARY_CDMS)
#if defined(ENABLE_PDF_VIEWER)
void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
content::PepperPluginInfo pdf_info;
pdf_info.is_internal = true;
@ -129,6 +133,7 @@ void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
pdf_info.permissions = ppapi::PERMISSION_PRIVATE | ppapi::PERMISSION_DEV;
plugins->push_back(pdf_info);
}
#endif // defined(ENABLE_PDF_VIEWER)
void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
const char* separator,
@ -220,7 +225,9 @@ void AtomContentClient::AddPepperPlugins(
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_LIBRARY_CDMS)
AddWidevineCdmFromCommandLine(plugins);
#endif // defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_LIBRARY_CDMS)
#if defined(ENABLE_PDF_VIEWER)
ComputeBuiltInPlugins(plugins);
#endif // defined(ENABLE_PDF_VIEWER)
}
} // namespace atom

3
atom/app/atom_main_delegate.cc
View file

@ -152,6 +152,9 @@ void AtomMainDelegate::PreSandboxStartup() {
}
}
// TODO(deepak1556): Fix and re-enable the plznavigation code path.
command_line->AppendSwitch(::switches::kDisableBrowserSideNavigation);
// Allow file:// URIs to read other file:// URIs by default.
command_line->AppendSwitch(::switches::kAllowFileAccessFromFiles);

4
atom/app/uv_task_runner.cc
View file

@ -20,7 +20,7 @@ UvTaskRunner::~UvTaskRunner() {
}
}
bool UvTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
bool UvTaskRunner::PostDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) {
auto* timer = new uv_timer_t;
@ -36,7 +36,7 @@ bool UvTaskRunner::RunsTasksInCurrentSequence() const {
}
bool UvTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) {
return PostDelayedTask(from_here, std::move(task), delay);

5
atom/app/uv_task_runner.h
View file

@ -8,6 +8,7 @@
#include <map>
#include "base/callback.h"
#include "base/location.h"
#include "base/single_thread_task_runner.h"
#include "vendor/node/deps/uv/include/uv.h"
@ -20,12 +21,12 @@ class UvTaskRunner : public base::SingleThreadTaskRunner {
~UvTaskRunner() override;
// base::SingleThreadTaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
bool PostDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksInCurrentSequence() const override;
bool PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override;

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

@ -484,7 +484,7 @@ int ImportIntoCertStore(
const base::DictionaryValue& options) {
std::string file_data, cert_path;
base::string16 password;
net::CertificateList imported_certs;
net::ScopedCERTCertificateList imported_certs;
int rv = -1;
options.GetString("certificate", &cert_path);
options.GetString("password", &password);
@ -659,7 +659,7 @@ void App::OnLogin(LoginHandler* login_handler,
request_details,
login_handler->auth_info(),
base::Bind(&PassLoginInformation,
make_scoped_refptr(login_handler)));
WrapRefCounted(login_handler)));
}
// Default behavior is to always cancel the auth.
@ -702,7 +702,6 @@ void App::AllowCertificateError(
const net::SSLInfo& ssl_info,
const GURL& request_url,
content::ResourceType resource_type,
bool overridable,
bool strict_enforcement,
bool expired_previous_decision,
const base::Callback<void(content::CertificateRequestResultType)>&

1
atom/browser/api/atom_api_app.h
View file

@ -133,7 +133,6 @@ class App : public AtomBrowserClient::Delegate,
const net::SSLInfo& ssl_info,
const GURL& request_url,
content::ResourceType resource_type,
bool overridable,
bool strict_enforcement,
bool expired_previous_decision,
const base::Callback<void(content::CertificateRequestResultType)>&

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

@ -41,13 +41,13 @@ namespace {
using CompletionCallback = base::Callback<void(const base::FilePath&)>;
scoped_refptr<TracingController::TraceDataSink> GetTraceDataSink(
scoped_refptr<TracingController::TraceDataEndpoint> GetTraceDataEndpoint(
const base::FilePath& path, const CompletionCallback& callback) {
base::FilePath result_file_path = path;
if (result_file_path.empty() && !base::CreateTemporaryFile(&result_file_path))
LOG(ERROR) << "Creating temporary file failed";
return TracingController::CreateFileSink(result_file_path,
return TracingController::CreateFileEndpoint(result_file_path,
base::Bind(callback,
result_file_path));
}
@ -55,7 +55,7 @@ scoped_refptr<TracingController::TraceDataSink> GetTraceDataSink(
void StopRecording(const base::FilePath& path,
const CompletionCallback& callback) {
TracingController::GetInstance()->StopTracing(
GetTraceDataSink(path, callback));
GetTraceDataEndpoint(path, callback));
}
void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,

8
atom/browser/api/atom_api_cookies.cc
View file

@ -250,7 +250,7 @@ Cookies::~Cookies() {}
void Cookies::Get(const base::DictionaryValue& filter,
const GetCallback& callback) {
std::unique_ptr<base::DictionaryValue> copied(filter.CreateDeepCopy());
auto getter = make_scoped_refptr(request_context_getter_);
auto getter = WrapRefCounted(request_context_getter_);
content::BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(GetCookiesOnIO, getter, Passed(&copied), callback));
@ -258,7 +258,7 @@ void Cookies::Get(const base::DictionaryValue& filter,
void Cookies::Remove(const GURL& url, const std::string& name,
const base::Closure& callback) {
auto getter = make_scoped_refptr(request_context_getter_);
auto getter = WrapRefCounted(request_context_getter_);
content::BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(RemoveCookieOnIOThread, getter, url, name, callback));
@ -267,14 +267,14 @@ void Cookies::Remove(const GURL& url, const std::string& name,
void Cookies::Set(const base::DictionaryValue& details,
const SetCallback& callback) {
std::unique_ptr<base::DictionaryValue> copied(details.CreateDeepCopy());
auto getter = make_scoped_refptr(request_context_getter_);
auto getter = WrapRefCounted(request_context_getter_);
content::BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(SetCookieOnIO, getter, Passed(&copied), callback));
}
void Cookies::FlushStore(const base::Closure& callback) {
auto getter = make_scoped_refptr(request_context_getter_);
auto getter = WrapRefCounted(request_context_getter_);
content::BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(FlushCookieStoreOnIOThread, getter, callback));

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

@ -31,11 +31,11 @@
#include "base/strings/string_util.h"
#include "base/threading/thread_task_runner_handle.h"
#include "brightray/browser/media/media_device_id_salt.h"
#include "brightray/browser/net/devtools_network_conditions.h"
#include "brightray/browser/net/devtools_network_controller_handle.h"
#include "chrome/browser/browser_process.h"
#include "chrome/common/pref_names.h"
#include "components/prefs/pref_service.h"
#include "content/common/devtools/devtools_network_conditions.h"
#include "content/common/devtools/devtools_network_controller.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/download_manager_delegate.h"
#include "content/public/browser/storage_partition.h"
@ -498,7 +498,7 @@ template<Session::CacheAction action>
void Session::DoCacheAction(const net::CompletionCallback& callback) {
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(&DoCacheActionInIO,
make_scoped_refptr(browser_context_->GetRequestContext()),
WrapRefCounted(browser_context_->GetRequestContext()),
action,
callback));
}
@ -543,23 +543,20 @@ void Session::SetDownloadPath(const base::FilePath& path) {
}
void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
std::unique_ptr<brightray::DevToolsNetworkConditions> conditions;
std::unique_ptr<content::DevToolsNetworkConditions> 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 brightray::DevToolsNetworkConditions(offline));
conditions.reset(new content::DevToolsNetworkConditions(offline));
} else {
options.Get("latency", &latency);
options.Get("downloadThroughput", &download_throughput);
options.Get("uploadThroughput", &upload_throughput);
conditions.reset(
new brightray::DevToolsNetworkConditions(false,
latency,
download_throughput,
upload_throughput));
conditions.reset(new content::DevToolsNetworkConditions(
false, latency, download_throughput, upload_throughput));
}
browser_context_->network_controller_handle()->SetNetworkState(
content::DevToolsNetworkController::SetNetworkState(
devtools_network_emulation_client_id_, std::move(conditions));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
@ -570,8 +567,8 @@ void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
}
void Session::DisableNetworkEmulation() {
std::unique_ptr<brightray::DevToolsNetworkConditions> conditions;
browser_context_->network_controller_handle()->SetNetworkState(
auto conditions = base::MakeUnique<content::DevToolsNetworkConditions>();
content::DevToolsNetworkController::SetNetworkState(
devtools_network_emulation_client_id_, std::move(conditions));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
@ -591,7 +588,7 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(&SetCertVerifyProcInIO,
make_scoped_refptr(browser_context_->GetRequestContext()),
WrapRefCounted(browser_context_->GetRequestContext()),
proc));
}
@ -613,7 +610,7 @@ void Session::ClearHostResolverCache(mate::Arguments* args) {
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(&ClearHostResolverCacheInIO,
make_scoped_refptr(browser_context_->GetRequestContext()),
WrapRefCounted(browser_context_->GetRequestContext()),
callback));
}
@ -629,14 +626,14 @@ void Session::ClearAuthCache(mate::Arguments* args) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&ClearAuthCacheInIO,
make_scoped_refptr(browser_context_->GetRequestContext()),
WrapRefCounted(browser_context_->GetRequestContext()),
options, callback));
}
void Session::AllowNTLMCredentialsForDomains(const std::string& domains) {
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(&AllowNTLMCredentialsForDomainsInIO,
make_scoped_refptr(browser_context_->GetRequestContext()),
WrapRefCounted(browser_context_->GetRequestContext()),
domains));
}

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

@ -55,7 +55,6 @@
#include "chrome/browser/ssl/security_state_tab_helper.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/browser/renderer_host/render_widget_host_view_base.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/common/view_messages.h"
#include "content/public/browser/child_process_security_policy.h"
#include "content/public/browser/favicon_status.h"
@ -893,10 +892,20 @@ void WebContents::DidFinishNavigation(
}
}
void WebContents::TitleWasSet(content::NavigationEntry* entry,
bool explicit_set) {
auto title = entry ? entry->GetTitle() : base::string16();
Emit("page-title-updated", title, explicit_set);
void WebContents::TitleWasSet(content::NavigationEntry* entry) {
base::string16 final_title;
bool explicit_set = true;
if (entry) {
auto title = entry->GetTitle();
auto url = entry->GetURL();
if (url.SchemeIsFile() && title.empty()) {
final_title = base::UTF8ToUTF16(url.ExtractFileName());
explicit_set = false;
} else {
final_title = title;
}
}
Emit("page-title-updated", final_title, explicit_set);
}
void WebContents::DidUpdateFaviconURL(
@ -964,7 +973,7 @@ bool WebContents::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(WebContents, message)
IPC_MESSAGE_HANDLER_CODE(ViewHostMsg_SetCursor, OnCursorChange,
handled = false)
handled = false)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
@ -1034,7 +1043,7 @@ void WebContents::NavigationEntryCommitted(
}
int64_t WebContents::GetIDForContents(content::WebContents* web_contents) {
int64_t process_id = web_contents->GetRenderProcessHost()->GetID();
int64_t process_id = web_contents->GetMainFrame()->GetProcess()->GetID();
int64_t routing_id = web_contents->GetMainFrame()->GetRoutingID();
int64_t rv = (process_id << 32) + routing_id;
return rv;
@ -1045,11 +1054,12 @@ int64_t WebContents::GetID() const {
}
int WebContents::GetProcessID() const {
return web_contents()->GetRenderProcessHost()->GetID();
return web_contents()->GetMainFrame()->GetProcess()->GetID();
}
base::ProcessId WebContents::GetOSProcessID() const {
auto process_handle = web_contents()->GetRenderProcessHost()->GetHandle();
auto process_handle =
web_contents()->GetMainFrame()->GetProcess()->GetHandle();
return base::GetProcId(process_handle);
}
@ -1267,14 +1277,30 @@ void WebContents::EnableDeviceEmulation(
if (type_ == REMOTE)
return;
Send(new ViewMsg_EnableDeviceEmulation(routing_id(), params));
auto frame_host = web_contents()->GetMainFrame();
if (frame_host) {
auto widget_host =
frame_host ? frame_host->GetView()->GetRenderWidgetHost() : nullptr;
if (!widget_host)
return;
widget_host->Send(
new ViewMsg_EnableDeviceEmulation(widget_host->GetRoutingID(), params));
}
}
void WebContents::DisableDeviceEmulation() {
if (type_ == REMOTE)
return;
Send(new ViewMsg_DisableDeviceEmulation(routing_id()));
auto frame_host = web_contents()->GetMainFrame();
if (frame_host) {
auto widget_host =
frame_host ? frame_host->GetView()->GetRenderWidgetHost() : nullptr;
if (!widget_host)
return;
widget_host->Send(
new ViewMsg_DisableDeviceEmulation(widget_host->GetRoutingID()));
}
}
void WebContents::ToggleDevTools() {
@ -1700,8 +1726,7 @@ void WebContents::StartPainting() {
return;
#if defined(ENABLE_OSR)
const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
auto* osr_wcv = GetOffScreenWebContentsView();
if (osr_wcv)
osr_wcv->SetPainting(true);
#endif
@ -1712,8 +1737,7 @@ void WebContents::StopPainting() {
return;
#if defined(ENABLE_OSR)
const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
auto* osr_wcv = GetOffScreenWebContentsView();
if (osr_wcv)
osr_wcv->SetPainting(false);
#endif
@ -1724,9 +1748,7 @@ bool WebContents::IsPainting() const {
return false;
#if defined(ENABLE_OSR)
const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
auto* osr_wcv = GetOffScreenWebContentsView();
return osr_wcv && osr_wcv->IsPainting();
#else
return false;
@ -1738,9 +1760,7 @@ void WebContents::SetFrameRate(int frame_rate) {
return;
#if defined(ENABLE_OSR)
const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
auto* osr_wcv = GetOffScreenWebContentsView();
if (osr_wcv)
osr_wcv->SetFrameRate(frame_rate);
#endif
@ -1751,9 +1771,7 @@ int WebContents::GetFrameRate() const {
return 0;
#if defined(ENABLE_OSR)
const auto* wc_impl = static_cast<content::WebContentsImpl*>(web_contents());
auto* osr_wcv = static_cast<OffScreenWebContentsView*>(wc_impl->GetView());
auto* osr_wcv = GetOffScreenWebContentsView();
return osr_wcv ? osr_wcv->GetFrameRate() : 0;
#else
return 0;

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

@ -48,6 +48,10 @@ class AtomJavaScriptDialogManager;
class WebContentsZoomController;
class WebViewGuestDelegate;
#if defined(ENABLE_OSR)
class OffScreenWebContentsView;
#endif
namespace api {
// Certain events are only in WebContentsDelegate, provide our own Observer to
@ -361,7 +365,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
void WebContentsDestroyed() override;
void NavigationEntryCommitted(
const content::LoadCommittedDetails& load_details) override;
void TitleWasSet(content::NavigationEntry* entry, bool explicit_set) override;
void TitleWasSet(content::NavigationEntry* entry) override;
void DidUpdateFaviconURL(
const std::vector<content::FaviconURL>& urls) override;
void PluginCrashed(const base::FilePath& plugin_path,
@ -393,6 +397,10 @@ class WebContents : public mate::TrackableObject<WebContents>,
return ++request_id_;
}
#if defined(ENABLE_OSR)
OffScreenWebContentsView* GetOffScreenWebContentsView() const;
#endif
// Called when we receive a CursorChange message from chromium.
void OnCursorChange(const content::WebCursor& cursor);

26
atom/browser/api/atom_api_web_contents_osr.cc Normal file
View file

@ -0,0 +1,26 @@
// 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/api/atom_api_web_contents.h"
#include "atom/browser/osr/osr_web_contents_view.h"
#include "content/browser/web_contents/web_contents_impl.h"
// Including both web_contents_impl.h and node.h would introduce a error, we
// have to isolate the usage of WebContentsImpl into a clean file to fix it:
// error C2371: 'ssize_t': redefinition; different basic types
namespace atom {
namespace api {
OffScreenWebContentsView* WebContents::GetOffScreenWebContentsView() const {
const auto* impl =
static_cast<const content::WebContentsImpl*>(web_contents());
return static_cast<OffScreenWebContentsView*>(impl->GetView());
}
} // namespace api
} // namespace atom

83
atom/browser/atom_access_token_store.cc
View file

@ -1,83 +0,0 @@
// Copyright (c) 2014 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/atom_access_token_store.h"
#include <string>
#include <utility>
#include "atom/common/google_api_key.h"
#include "base/environment.h"
#include "content/public/browser/browser_thread.h"
#include "device/geolocation/geolocation_provider.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"
using content::BrowserThread;
namespace atom {
namespace internal {
class GeoURLRequestContextGetter : public net::URLRequestContextGetter {
public:
net::URLRequestContext* GetURLRequestContext() override {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!url_request_context_.get()) {
net::URLRequestContextBuilder builder;
builder.set_proxy_config_service(
net::ProxyService::CreateSystemProxyConfigService(
BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
url_request_context_ = builder.Build();
}
return url_request_context_.get();
}
scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
const override {
return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
}
private:
friend class atom::AtomAccessTokenStore;
GeoURLRequestContextGetter() {}
~GeoURLRequestContextGetter() override {}
std::unique_ptr<net::URLRequestContext> url_request_context_;
DISALLOW_COPY_AND_ASSIGN(GeoURLRequestContextGetter);
};
} // namespace internal
AtomAccessTokenStore::AtomAccessTokenStore()
: request_context_getter_(new internal::GeoURLRequestContextGetter) {
}
AtomAccessTokenStore::~AtomAccessTokenStore() {
}
void AtomAccessTokenStore::LoadAccessTokens(
const LoadAccessTokensCallback& callback) {
std::unique_ptr<base::Environment> env(base::Environment::Create());
std::string api_key;
if (!env->GetVar("GOOGLE_API_KEY", &api_key))
api_key = GOOGLEAPIS_API_KEY;
// Equivalent to access_token_map[kGeolocationProviderURL].
// Somehow base::string16 is causing compilation errors when used in a pair
// of std::map on Linux, this can work around it.
device::AccessTokenStore::AccessTokenMap access_token_map;
std::pair<GURL, base::string16> token_pair;
token_pair.first = GURL(GOOGLEAPIS_ENDPOINT + api_key);
access_token_map.insert(token_pair);
callback.Run(access_token_map, request_context_getter_.get());
}
void AtomAccessTokenStore::SaveAccessToken(const GURL& server_url,
const base::string16& access_token) {
}
} // namespace atom

14
atom/browser/atom_access_token_store.h
View file

@ -9,23 +9,17 @@
namespace atom {
namespace internal {
class GeoURLRequestContextGetter;
}
class AtomAccessTokenStore : public device::AccessTokenStore {
public:
AtomAccessTokenStore();
~AtomAccessTokenStore();
AtomAccessTokenStore() = default;
~AtomAccessTokenStore() = default;
// device::AccessTokenStore:
void LoadAccessTokens(
const LoadAccessTokensCallback& callback) override;
void LoadAccessTokens(const LoadAccessTokensCallback& callback) override {}
void SaveAccessToken(const GURL& server_url,
const base::string16& access_token) override;
const base::string16& access_token) override {}
private:
scoped_refptr<internal::GeoURLRequestContextGetter> request_context_getter_;
DISALLOW_COPY_AND_ASSIGN(AtomAccessTokenStore);
};

37
atom/browser/atom_browser_client.cc
View file

@ -22,8 +22,10 @@
#include "atom/browser/web_contents_permission_helper.h"
#include "atom/browser/web_contents_preferences.h"
#include "atom/browser/window_list.h"
#include "atom/common/google_api_key.h"
#include "atom/common/options_switches.h"
#include "base/command_line.h"
#include "base/environment.h"
#include "base/files/file_util.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
@ -50,6 +52,8 @@
#include "ui/base/l10n/l10n_util.h"
#include "v8/include/v8.h"
using content::BrowserThread;
namespace atom {
namespace {
@ -75,8 +79,7 @@ void AtomBrowserClient::SetCustomServiceWorkerSchemes(
g_custom_service_worker_schemes = base::JoinString(schemes, ",");
}
AtomBrowserClient::AtomBrowserClient() : delegate_(nullptr) {
}
AtomBrowserClient::AtomBrowserClient() : delegate_(nullptr) {}
AtomBrowserClient::~AtomBrowserClient() {
}
@ -203,7 +206,8 @@ void AtomBrowserClient::OverrideWebkitPrefs(
prefs->application_cache_enabled = true;
prefs->allow_universal_access_from_file_urls = true;
prefs->allow_file_access_from_file_urls = true;
prefs->experimental_webgl_enabled = true;
prefs->webgl1_enabled = true;
prefs->webgl2_enabled = true;
prefs->allow_running_insecure_content = false;
// Custom preferences of guest page.
@ -261,8 +265,8 @@ void AtomBrowserClient::OverrideSiteInstanceForNavigation(
// when this function returns.
// FIXME(zcbenz): We should adjust
// OverrideSiteInstanceForNavigation's interface to solve this.
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&Noop, base::RetainedRef(site_instance)));
// Remember the original web contents for the pending renderer process.
@ -337,6 +341,24 @@ void AtomBrowserClient::DidCreatePpapiPlugin(
base::WrapUnique(new chrome::ChromeBrowserPepperHostFactory(host)));
}
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;
if (!env->GetVar("GOOGLE_API_KEY", &api_key))
api_key = GOOGLEAPIS_API_KEY;
return api_key;
}
content::QuotaPermissionContext*
AtomBrowserClient::CreateQuotaPermissionContext() {
return new AtomQuotaPermissionContext;
@ -348,7 +370,6 @@ void AtomBrowserClient::AllowCertificateError(
const net::SSLInfo& ssl_info,
const GURL& request_url,
content::ResourceType resource_type,
bool overridable,
bool strict_enforcement,
bool expired_previous_decision,
const base::Callback<void(content::CertificateRequestResultType)>&
@ -356,7 +377,7 @@ void AtomBrowserClient::AllowCertificateError(
if (delegate_) {
delegate_->AllowCertificateError(
web_contents, cert_error, ssl_info, request_url,
resource_type, overridable, strict_enforcement,
resource_type, strict_enforcement,
expired_previous_decision, callback);
}
}
@ -396,7 +417,7 @@ bool AtomBrowserClient::CanCreateWindow(
bool user_gesture,
bool opener_suppressed,
bool* no_javascript_access) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DCHECK_CURRENTLY_ON(BrowserThread::UI);
int opener_render_process_id = opener->GetProcess()->GetID();

5
atom/browser/atom_browser_client.h
View file

@ -62,6 +62,10 @@ 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(
content::WebContents* web_contents,
@ -69,7 +73,6 @@ class AtomBrowserClient : public brightray::BrowserClient,
const net::SSLInfo& ssl_info,
const GURL& request_url,
content::ResourceType resource_type,
bool overridable,
bool strict_enforcement,
bool expired_previous_decision,
const base::Callback<void(content::CertificateRequestResultType)>&

10
atom/browser/atom_browser_context.cc
View file

@ -27,8 +27,8 @@
#include "base/path_service.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/task_scheduler/post_task.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/threading/worker_pool.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/pref_names.h"
#include "components/prefs/pref_registry_simple.h"
@ -135,9 +135,11 @@ AtomBrowserContext::CreateURLRequestJobFactory(
job_factory->SetProtocolHandler(
url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler));
job_factory->SetProtocolHandler(
url::kFileScheme, base::WrapUnique(new asar::AsarProtocolHandler(
BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
url::kFileScheme,
base::WrapUnique(
new asar::AsarProtocolHandler(base::CreateTaskRunnerWithTraits(
{base::MayBlock(), base::TaskPriority::USER_VISIBLE,
base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}))));
job_factory->SetProtocolHandler(
url::kHttpScheme,
base::WrapUnique(new HttpProtocolHandler(url::kHttpScheme)));

7
atom/browser/atom_browser_main_parts.cc
View file

@ -9,7 +9,6 @@
#include "atom/browser/atom_access_token_store.h"
#include "atom/browser/atom_browser_client.h"
#include "atom/browser/atom_browser_context.h"
#include "atom/browser/atom_web_ui_controller_factory.h"
#include "atom/browser/bridge_task_runner.h"
#include "atom/browser/browser.h"
#include "atom/browser/javascript_environment.h"
@ -33,6 +32,10 @@
#include "ui/events/devices/x11/touch_factory_x11.h"
#endif
#if defined(ENABLE_PDF_VIEWER)
#include "atom/browser/atom_web_ui_controller_factory.h"
#endif // defined(ENABLE_PDF_VIEWER)
namespace atom {
namespace {
@ -186,8 +189,10 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
base::Bind(&v8::Isolate::LowMemoryNotification,
base::Unretained(js_env_->isolate())));
#if defined(ENABLE_PDF_VIEWER)
content::WebUIControllerFactory::RegisterFactory(
AtomWebUIControllerFactory::GetInstance());
#endif // defined(ENABLE_PDF_VIEWER)
brightray::BrowserMainParts::PreMainMessageLoopRun();
bridge_task_runner_->MessageLoopIsReady();

20
atom/browser/atom_javascript_dialog_manager.cc
View file

@ -35,16 +35,16 @@ void AtomJavaScriptDialogManager::RunJavaScriptDialog(
JavaScriptDialogType dialog_type,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback,
DialogClosedCallback callback,
bool* did_suppress_message) {
const std::string origin = origin_url.GetOrigin().spec();
const std::string& origin = origin_url.GetOrigin().spec();
if (origin_counts_[origin] == kUserWantsNoMoreDialogs) {
return callback.Run(false, base::string16());
return std::move(callback).Run(false, base::string16());
}
if (dialog_type != JavaScriptDialogType::JAVASCRIPT_DIALOG_TYPE_ALERT &&
dialog_type != JavaScriptDialogType::JAVASCRIPT_DIALOG_TYPE_CONFIRM) {
callback.Run(false, base::string16());
std::move(callback).Run(false, base::string16());
return;
}
@ -73,15 +73,17 @@ void AtomJavaScriptDialogManager::RunJavaScriptDialog(
base::UTF16ToUTF8(message_text), "", checkbox_string,
false, gfx::ImageSkia(),
base::Bind(&AtomJavaScriptDialogManager::OnMessageBoxCallback,
base::Unretained(this), callback, origin));
base::Unretained(this),
base::Passed(std::move(callback)),
origin));
}
void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
content::WebContents* web_contents,
bool is_reload,
const DialogClosedCallback& callback) {
DialogClosedCallback callback) {
bool default_prevented = api_web_contents_->Emit("will-prevent-unload");
callback.Run(default_prevented, base::string16());
std::move(callback).Run(default_prevented, base::string16());
return;
}
@ -91,13 +93,13 @@ void AtomJavaScriptDialogManager::CancelDialogs(
}
void AtomJavaScriptDialogManager::OnMessageBoxCallback(
const DialogClosedCallback& callback,
DialogClosedCallback callback,
const std::string& origin,
int code,
bool checkbox_checked) {
if (checkbox_checked)
origin_counts_[origin] = kUserWantsNoMoreDialogs;
callback.Run(code == 0, base::string16());
std::move(callback).Run(code == 0, base::string16());
}
} // namespace atom

6
atom/browser/atom_javascript_dialog_manager.h
View file

@ -27,17 +27,17 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
content::JavaScriptDialogType dialog_type,
const base::string16& message_text,
const base::string16& default_prompt_text,
const DialogClosedCallback& callback,
DialogClosedCallback callback,
bool* did_suppress_message) override;
void RunBeforeUnloadDialog(
content::WebContents* web_contents,
bool is_reload,
const DialogClosedCallback& callback) override;
DialogClosedCallback callback) override;
void CancelDialogs(content::WebContents* web_contents,
bool reset_state) override;
private:
void OnMessageBoxCallback(const DialogClosedCallback& callback,
void OnMessageBoxCallback(DialogClosedCallback callback,
const std::string& origin,
int code,
bool checkbox_checked);

16
atom/browser/atom_resource_dispatcher_host_delegate.cc
View file

@ -8,17 +8,13 @@
#include "atom/browser/login_handler.h"
#include "atom/browser/web_contents_permission_helper.h"
#include "atom/browser/web_contents_preferences.h"
#include "atom/common/atom_constants.h"
#include "atom/common/platform_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/download_manager.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/stream_info.h"
#include "net/base/escape.h"
#include "net/ssl/client_cert_store.h"
#include "net/url_request/url_request.h"
#include "url/gurl.h"
#if defined(USE_NSS_CERTS)
@ -29,6 +25,14 @@
#include "net/ssl/client_cert_store_mac.h"
#endif
#if defined(ENABLE_PDF_VIEWER)
#include "atom/common/atom_constants.h"
#include "base/strings/stringprintf.h"
#include "content/public/browser/stream_info.h"
#include "net/url_request/url_request.h"
#endif // defined(ENABLE_PDF_VIEWER)
using content::BrowserThread;
namespace atom {
@ -65,6 +69,7 @@ void HandleExternalProtocolInUI(
url);
}
#if defined(ENABLE_PDF_VIEWER)
void OnPdfResourceIntercepted(
const GURL& original_url,
int render_process_host_id,
@ -102,6 +107,7 @@ void OnPdfResourceIntercepted(
params.frame_tree_node_id = frame_host->GetFrameTreeNodeId();
web_contents->GetController().LoadURLWithParams(params);
}
#endif // defined(ENABLE_PDF_VIEWER)
} // namespace
@ -145,6 +151,7 @@ bool AtomResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
const std::string& mime_type,
GURL* origin,
std::string* payload) {
#if defined(ENABLE_PDF_VIEWER)
const content::ResourceRequestInfo* info =
content::ResourceRequestInfo::ForRequest(request);
@ -164,6 +171,7 @@ bool AtomResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
info->GetWebContentsGetterForRequest()));
return true;
}
#endif // defined(ENABLE_PDF_VIEWER)
return false;
}

6
atom/browser/atom_web_ui_controller_factory.cc
View file

@ -6,12 +6,14 @@
#include <string>
#if defined(ENABLE_PDF_VIEWER)
#include "atom/browser/ui/webui/pdf_viewer_ui.h"
#include "atom/common/atom_constants.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "content/public/browser/web_contents.h"
#include "net/base/escape.h"
#endif // defined(ENABLE_PDF_VIEWER)
namespace atom {
@ -27,9 +29,11 @@ AtomWebUIControllerFactory::~AtomWebUIControllerFactory() {}
content::WebUI::TypeID AtomWebUIControllerFactory::GetWebUIType(
content::BrowserContext* browser_context,
const GURL& url) const {
#if defined(ENABLE_PDF_VIEWER)
if (url.host() == kPdfViewerUIHost) {
return const_cast<AtomWebUIControllerFactory*>(this);
}
#endif // defined(ENABLE_PDF_VIEWER)
return content::WebUI::kNoWebUI;
}
@ -49,6 +53,7 @@ bool AtomWebUIControllerFactory::UseWebUIBindingsForURL(
content::WebUIController*
AtomWebUIControllerFactory::CreateWebUIControllerForURL(content::WebUI* web_ui,
const GURL& url) const {
#if defined(ENABLE_PDF_VIEWER)
if (url.host() == kPdfViewerUIHost) {
base::StringPairs toplevel_params;
base::SplitStringIntoKeyValuePairs(url.query(), '=', '&', &toplevel_params);
@ -70,6 +75,7 @@ AtomWebUIControllerFactory::CreateWebUIControllerForURL(content::WebUI* web_ui,
auto browser_context = web_ui->GetWebContents()->GetBrowserContext();
return new PdfViewerUI(browser_context, web_ui, src);
}
#endif // defined(ENABLE_PDF_VIEWER)
return nullptr;
}

4
atom/browser/bridge_task_runner.cc
View file

@ -22,7 +22,7 @@ void BridgeTaskRunner::MessageLoopIsReady() {
}
bool BridgeTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) {
auto message_loop = base::MessageLoop::current();
@ -44,7 +44,7 @@ bool BridgeTaskRunner::RunsTasksInCurrentSequence() const {
}
bool BridgeTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) {
auto message_loop = base::MessageLoop::current();

7
atom/browser/bridge_task_runner.h
View file

@ -8,6 +8,7 @@
#include <tuple>
#include <vector>
#include "base/location.h"
#include "base/single_thread_task_runner.h"
#include "base/tuple.h"
@ -24,18 +25,18 @@ class BridgeTaskRunner : public base::SingleThreadTaskRunner {
void MessageLoopIsReady();
// base::SingleThreadTaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
bool PostDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksInCurrentSequence() const override;
bool PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override;
private:
using TaskPair = std::tuple<
tracked_objects::Location, base::OnceClosure, base::TimeDelta>;
base::Location, base::OnceClosure, base::TimeDelta>;
std::vector<TaskPair> tasks_;
std::vector<TaskPair> non_nestable_tasks_;

2
atom/browser/login_handler.cc
View file

@ -49,7 +49,7 @@ LoginHandler::LoginHandler(net::AuthChallengeInfo* auth_info,
BrowserThread::UI, FROM_HERE,
base::Bind(&Browser::RequestLogin,
base::Unretained(Browser::Get()),
base::RetainedRef(make_scoped_refptr(this)),
base::RetainedRef(WrapRefCounted(this)),
base::Passed(&request_details)));
}

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

@ -144,7 +144,7 @@ int URLRequestAsarJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
dest_size,
base::Bind(&URLRequestAsarJob::DidRead,
weak_ptr_factory_.GetWeakPtr(),
make_scoped_refptr(dest)));
WrapRefCounted(dest)));
if (rv >= 0) {
remaining_bytes_ -= rv;
DCHECK_GE(remaining_bytes_, 0);

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

@ -10,12 +10,12 @@
#include "atom/common/native_mate_converters/net_converter.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
#include "brightray/browser/net/devtools_network_transaction.h"
#include "content/common/devtools/devtools_network_transaction.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_frame_host.h"
#include "net/url_request/url_request.h"
using brightray::DevToolsNetworkTransaction;
using content::DevToolsNetworkTransaction;
using content::BrowserThread;
namespace atom {
@ -266,9 +266,9 @@ int AtomNetworkDelegate::OnBeforeStartTransaction(
const net::CompletionCallback& callback,
net::HttpRequestHeaders* headers) {
if (!client_id_.empty())
headers->SetHeader(
DevToolsNetworkTransaction::kDevToolsEmulateNetworkConditionsClientId,
client_id_);
headers->SetHeader(content::DevToolsNetworkTransaction::
kDevToolsEmulateNetworkConditionsClientId,
client_id_);
if (!base::ContainsKey(response_listeners_, kOnBeforeSendHeaders))
return brightray::NetworkDelegate::OnBeforeStartTransaction(
request, callback, headers);

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

@ -444,7 +444,7 @@ bool AtomURLRequest::CopyAndPostBuffer(int bytes_read) {
// data is only a wrapper for the asynchronous response_read_buffer_.
// Make a deep copy of payload and transfer ownership to the UI thread.
auto buffer_copy = make_scoped_refptr(new net::IOBufferWithSize(bytes_read));
auto buffer_copy = WrapRefCounted(new net::IOBufferWithSize(bytes_read));
memcpy(buffer_copy->data(), response_read_buffer_->data(), bytes_read);
return content::BrowserThread::PostTask(

8
atom/browser/net/url_request_async_asar_job.cc
View file

@ -7,7 +7,7 @@
#include <string>
#include "atom/common/atom_constants.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/task_scheduler/post_task.h"
namespace atom {
@ -31,9 +31,9 @@ void URLRequestAsyncAsarJob::StartAsync(std::unique_ptr<base::Value> options) {
net::URLRequestStatus::FAILED, net::ERR_NOT_IMPLEMENTED));
} else {
asar::URLRequestAsarJob::Initialize(
content::BrowserThread::GetBlockingPool()->
GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN),
base::CreateSequencedTaskRunnerWithTraits(
{base::MayBlock(), base::TaskPriority::USER_VISIBLE,
base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}),
base::FilePath(file_path));
asar::URLRequestAsarJob::Start();
}

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

@ -96,9 +96,9 @@ void URLRequestFetchJob::BeforeStartInUI(
if (val->IsNull()) {
// We have to create the URLRequestContextGetter on UI thread.
url_request_context_getter_ = new brightray::URLRequestContextGetter(
this, nullptr, nullptr, base::FilePath(), true,
BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
nullptr, content::URLRequestInterceptorScopedVector());
this, nullptr, base::FilePath(), true,
BrowserThread::GetTaskRunnerForThread(BrowserThread::IO), nullptr,
content::URLRequestInterceptorScopedVector());
} else {
mate::Handle<api::Session> session;
if (mate::ConvertFromV8(isolate, val, &session) && !session.IsEmpty()) {

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

@ -119,7 +119,7 @@ int URLRequestStreamJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&URLRequestStreamJob::CopyMoreData, weak_factory_.GetWeakPtr(),
make_scoped_refptr(dest), dest_size));
WrapRefCounted(dest), dest_size));
return net::ERR_IO_PENDING;
}

2
atom/browser/osr/osr_output_device.cc
View file

@ -73,7 +73,7 @@ void OffScreenOutputDevice::EndPaint() {
if (!bitmap_.get()) return;
cc::SoftwareOutputDevice::EndPaint();
viz::SoftwareOutputDevice::EndPaint();
if (active_)
OnPaint(damage_rect_);

6
atom/browser/osr/osr_output_device.h
View file

@ -6,7 +6,7 @@
#define ATOM_BROWSER_OSR_OSR_OUTPUT_DEVICE_H_
#include "base/callback.h"
#include "cc/output/software_output_device.h"
#include "components/viz/service/display/software_output_device.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
@ -14,12 +14,12 @@ namespace atom {
typedef base::Callback<void(const gfx::Rect&, const SkBitmap&)> OnPaintCallback;
class OffScreenOutputDevice : public cc::SoftwareOutputDevice {
class OffScreenOutputDevice : public viz::SoftwareOutputDevice {
public:
OffScreenOutputDevice(bool transparent, const OnPaintCallback& callback);
~OffScreenOutputDevice();
// cc::SoftwareOutputDevice:
// viz::SoftwareOutputDevice:
void Resize(const gfx::Size& pixel_size, float scale_factor) override;
SkCanvas* BeginPaint(const gfx::Rect& damage_rect) override;
void EndPaint() override;

37
atom/browser/osr/osr_render_widget_host_view.cc
View file

@ -14,9 +14,10 @@
#include "base/memory/ptr_util.h"
#include "base/single_thread_task_runner.h"
#include "base/time/time.h"
#include "components/viz/common/frame_sinks/copy_output_request.h"
#include "components/viz/common/frame_sinks/delay_based_time_source.h"
#include "components/viz/common/gl_helper.h"
#include "components/viz/common/quads/copy_output_request.h"
#include "components/viz/common/quads/render_pass.h"
#include "content/browser/renderer_host/compositor_resize_lock.h"
#include "content/browser/renderer_host/render_widget_host_delegate.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
@ -127,8 +128,9 @@ class AtomCopyFrameGenerator {
if (!view_->render_widget_host() || !view_->IsPainting())
return;
std::unique_ptr<viz::CopyOutputRequest> request =
viz::CopyOutputRequest::CreateBitmapRequest(base::Bind(
auto request = std::make_unique<viz::CopyOutputRequest>(
viz::CopyOutputRequest::ResultFormat::RGBA_BITMAP,
base::BindOnce(
&AtomCopyFrameGenerator::CopyFromCompositingSurfaceHasResult,
weak_ptr_factory_.GetWeakPtr(),
damage_rect));
@ -152,9 +154,9 @@ class AtomCopyFrameGenerator {
return;
}
DCHECK(result->HasBitmap());
std::unique_ptr<SkBitmap> source = result->TakeBitmap();
DCHECK(source);
DCHECK(!result->IsEmpty());
auto source = std::make_unique<SkBitmap>(result->AsSkBitmap());
DCHECK(source->readyToDraw());
if (source) {
base::AutoLock autolock(lock_);
std::shared_ptr<SkBitmap> bitmap(source.release());
@ -289,11 +291,14 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
bool is_guest_view_hack = parent_host_view_ != nullptr;
#if !defined(OS_MACOSX)
delegated_frame_host_ = base::MakeUnique<content::DelegatedFrameHost>(
AllocateFrameSinkId(is_guest_view_hack), this);
AllocateFrameSinkId(is_guest_view_hack), this,
false /* enable_surface_synchronization */);
root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
#endif
local_surface_id_ = local_surface_id_allocator_.GenerateId();
#if defined(OS_MACOSX)
CreatePlatformWidget(is_guest_view_hack);
#else
@ -544,7 +549,7 @@ void OffScreenRenderWidgetHostView::DidCreateNewRendererCompositorFrameSink(
void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
const viz::LocalSurfaceId& local_surface_id,
cc::CompositorFrame frame) {
viz::CompositorFrame frame) {
TRACE_EVENT0("electron",
"OffScreenRenderWidgetHostView::SubmitCompositorFrame");
@ -573,7 +578,7 @@ void OffScreenRenderWidgetHostView::SubmitCompositorFrame(
// Determine the damage rectangle for the current frame. This is the same
// calculation that SwapDelegatedFrame uses.
cc::RenderPass* root_pass = frame.render_pass_list.back().get();
viz::RenderPass* root_pass = frame.render_pass_list.back().get();
gfx::Size frame_size = root_pass->output_rect.size();
gfx::Rect damage_rect =
gfx::ToEnclosingRect(gfx::RectF(root_pass->damage_rect));
@ -719,7 +724,7 @@ void OffScreenRenderWidgetHostView::ImeCompositionRangeChanged(
}
gfx::Size OffScreenRenderWidgetHostView::GetPhysicalBackingSize() const {
return gfx::ConvertSizeToPixel(scale_factor_, GetRequestedRendererSize());
return gfx::ScaleToCeiledSize(GetRequestedRendererSize(), scale_factor_);
}
gfx::Size OffScreenRenderWidgetHostView::GetRequestedRendererSize() const {
@ -786,6 +791,10 @@ OffScreenRenderWidgetHostView::DelegatedFrameHostCreateResizeLock() {
return base::MakeUnique<content::CompositorResizeLock>(this, desired_size);
}
viz::LocalSurfaceId OffScreenRenderWidgetHostView::GetLocalSurfaceId() const {
return local_surface_id_;
}
void OffScreenRenderWidgetHostView::OnBeginFrame() {
}
@ -902,7 +911,7 @@ void OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped(
RegisterGuestViewFrameSwappedCallback(guest_host_view);
}
std::unique_ptr<cc::SoftwareOutputDevice>
std::unique_ptr<viz::SoftwareOutputDevice>
OffScreenRenderWidgetHostView::CreateSoftwareOutputDevice(
ui::Compositor* compositor) {
DCHECK_EQ(GetCompositor(), compositor);
@ -922,9 +931,9 @@ bool OffScreenRenderWidgetHostView::InstallTransparency() {
if (transparent_) {
SetBackgroundColor(SkColor());
#if defined(OS_MACOSX)
browser_compositor_->SetHasTransparentBackground(true);
browser_compositor_->SetBackgroundColor(SK_ColorTRANSPARENT);
#else
compositor_->SetHostHasTransparentBackground(true);
compositor_->SetBackgroundColor(SK_ColorTRANSPARENT);
#endif
return true;
}
@ -1260,6 +1269,8 @@ void OffScreenRenderWidgetHostView::ResizeRootLayer() {
const gfx::Size& size_in_pixels =
gfx::ConvertSizeToPixel(scale_factor_, size);
local_surface_id_ = local_surface_id_allocator_.GenerateId();
GetRootLayer()->SetBounds(gfx::Rect(size));
GetCompositor()->SetScaleAndSize(scale_factor_, size_in_pixels);
}

15
atom/browser/osr/osr_render_widget_host_view.h
View file

@ -20,9 +20,10 @@
#include "base/process/kill.h"
#include "base/threading/thread.h"
#include "base/time/time.h"
#include "cc/output/compositor_frame.h"
#include "components/viz/common/frame_sinks/begin_frame_args.h"
#include "components/viz/common/frame_sinks/begin_frame_source.h"
#include "components/viz/common/quads/compositor_frame.h"
#include "components/viz/common/surfaces/local_surface_id_allocator.h"
#include "content/browser/frame_host/render_widget_host_view_guest.h"
#include "content/browser/renderer_host/compositor_resize_lock.h"
#include "content/browser/renderer_host/delegated_frame_host.h"
@ -122,7 +123,7 @@ class OffScreenRenderWidgetHostView
viz::mojom::CompositorFrameSinkClient* renderer_compositor_frame_sink)
override;
void SubmitCompositorFrame(const viz::LocalSurfaceId& local_surface_id,
cc::CompositorFrame frame) override;
viz::CompositorFrame frame) override;
void ClearCompositorFrame(void) override;
void InitAsPopup(content::RenderWidgetHostView *rwhv, const gfx::Rect& rect)
@ -179,6 +180,7 @@ class OffScreenRenderWidgetHostView
bool DelegatedFrameCanCreateResizeLock() const override;
std::unique_ptr<content::CompositorResizeLock>
DelegatedFrameHostCreateResizeLock() override;
viz::LocalSurfaceId GetLocalSurfaceId() const override;
void OnBeginFrame() override;
// CompositorResizeLockClient implementation.
std::unique_ptr<ui::CompositorLock> GetCompositorLock(
@ -196,7 +198,7 @@ class OffScreenRenderWidgetHostView
gfx::Point* transformed_point) override;
// ui::CompositorDelegate:
std::unique_ptr<cc::SoftwareOutputDevice> CreateSoftwareOutputDevice(
std::unique_ptr<viz::SoftwareOutputDevice> CreateSoftwareOutputDevice(
ui::Compositor* compositor) override;
bool InstallTransparency();
@ -274,6 +276,10 @@ class OffScreenRenderWidgetHostView
child_host_view_ = child_view;
}
viz::LocalSurfaceId local_surface_id() const {
return local_surface_id_;
}
private:
void SetupFrameRate(bool force);
void ResizeRootLayer();
@ -320,6 +326,9 @@ class OffScreenRenderWidgetHostView
bool paint_callback_running_;
viz::LocalSurfaceId local_surface_id_;
viz::LocalSurfaceIdAllocator local_surface_id_allocator_;
std::unique_ptr<ui::Layer> root_layer_;
std::unique_ptr<ui::Compositor> compositor_;
std::unique_ptr<content::DelegatedFrameHost> delegated_frame_host_;

9
atom/browser/osr/osr_render_widget_host_view_mac.mm
View file

@ -16,7 +16,10 @@ class MacHelper :
public content::BrowserCompositorMacClient,
public ui::AcceleratedWidgetMacNSView {
public:
explicit MacHelper(OffScreenRenderWidgetHostView* view) : view_(view) {}
explicit MacHelper(OffScreenRenderWidgetHostView* view) : view_(view) {
[this->AcceleratedWidgetGetNSView() setWantsLayer:YES];
}
virtual ~MacHelper() {}
// content::BrowserCompositorMacClient:
@ -40,6 +43,10 @@ class MacHelper :
void BrowserCompositorMacOnBeginFrame() override {}
viz::LocalSurfaceId GetLocalSurfaceId() const override {
return view_->local_surface_id();
}
// ui::AcceleratedWidgetMacNSView:
NSView* AcceleratedWidgetGetNSView() const override {
return [view_->window()->GetNativeWindow() contentView];

4
atom/browser/ui/webui/pdf_viewer_handler.h
View file

@ -5,6 +5,10 @@
#ifndef ATOM_BROWSER_UI_WEBUI_PDF_VIEWER_HANDLER_H_
#define ATOM_BROWSER_UI_WEBUI_PDF_VIEWER_HANDLER_H_
#ifndef ENABLE_PDF_VIEWER
#error("This header can only be used when enable_pdf_viewer gyp flag is enabled") // NOLINT
#endif // defined(ENABLE_PDF_VIEWER)
#include <string>
#include "atom/browser/web_contents_zoom_controller.h"

4
atom/browser/ui/webui/pdf_viewer_ui.h
View file

@ -5,6 +5,10 @@
#ifndef ATOM_BROWSER_UI_WEBUI_PDF_VIEWER_UI_H_
#define ATOM_BROWSER_UI_WEBUI_PDF_VIEWER_UI_H_
#ifndef ENABLE_PDF_VIEWER
#error("This header can only be used when enable_pdf_viewer gyp flag is enabled") // NOLINT
#endif // defined(ENABLE_PDF_VIEWER)
#include <string>
#include "base/macros.h"

9
atom/browser/web_contents_preferences.cc
View file

@ -16,6 +16,7 @@
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "cc/base/switches.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/web_preferences.h"
@ -97,7 +98,7 @@ content::WebContents* WebContentsPreferences::GetWebContentsFromProcessID(
int process_id) {
for (WebContentsPreferences* preferences : instances_) {
content::WebContents* web_contents = preferences->web_contents_;
if (web_contents->GetRenderProcessHost()->GetID() == process_id)
if (web_contents->GetMainFrame()->GetProcess()->GetID() == process_id)
return web_contents;
}
return nullptr;
@ -293,8 +294,10 @@ void WebContentsPreferences::OverrideWebkitPrefs(
prefs->images_enabled = b;
if (self->web_preferences_.GetBoolean("textAreasAreResizable", &b))
prefs->text_areas_are_resizable = b;
if (self->web_preferences_.GetBoolean("webgl", &b))
prefs->experimental_webgl_enabled = b;
if (self->web_preferences_.GetBoolean("webgl", &b)) {
prefs->webgl1_enabled = b;
prefs->webgl2_enabled = b;
}
if (self->web_preferences_.GetBoolean("webSecurity", &b)) {
prefs->web_security_enabled = b;
prefs->allow_running_insecure_content = !b;

15
atom/browser/web_contents_zoom_controller.cc
View file

@ -7,6 +7,7 @@
#include "content/public/browser/navigation_details.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/navigation_handle.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents.h"
@ -53,7 +54,8 @@ void WebContentsZoomController::SetZoomLevel(double level) {
zoom_mode_ == ZOOM_MODE_DISABLED)
return;
int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
int render_process_id =
web_contents()->GetRenderViewHost()->GetProcess()->GetID();
int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
if (zoom_mode_ == ZOOM_MODE_MANUAL) {
@ -98,7 +100,7 @@ double WebContentsZoomController::GetDefaultZoomFactor() {
}
void WebContentsZoomController::SetTemporaryZoomLevel(double level) {
old_process_id_ = web_contents()->GetRenderProcessHost()->GetID();
old_process_id_ = web_contents()->GetRenderViewHost()->GetProcess()->GetID();
old_view_id_ = web_contents()->GetRenderViewHost()->GetRoutingID();
host_zoom_map_->SetTemporaryZoomLevel(old_process_id_, old_view_id_, level);
// Notify observers of zoom level changes.
@ -107,7 +109,8 @@ void WebContentsZoomController::SetTemporaryZoomLevel(double level) {
}
bool WebContentsZoomController::UsesTemporaryZoomLevel() {
int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
int render_process_id =
web_contents()->GetRenderViewHost()->GetProcess()->GetID();
int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
return host_zoom_map_->UsesTemporaryZoomLevel(render_process_id,
render_view_id);
@ -120,7 +123,8 @@ void WebContentsZoomController::SetZoomMode(ZoomMode new_mode) {
content::HostZoomMap* zoom_map =
content::HostZoomMap::GetForWebContents(web_contents());
int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
int render_process_id =
web_contents()->GetRenderViewHost()->GetProcess()->GetID();
int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
double original_zoom_level = GetZoomLevel();
@ -203,7 +207,8 @@ void WebContentsZoomController::ResetZoomModeOnNavigationIfNeeded(
if (zoom_mode_ != ZOOM_MODE_ISOLATED && zoom_mode_ != ZOOM_MODE_MANUAL)
return;
int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
int render_process_id =
web_contents()->GetRenderViewHost()->GetProcess()->GetID();
int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
content::HostZoomMap* zoom_map =
content::HostZoomMap::GetForWebContents(web_contents());

3
atom/browser/web_view_manager.cc
View file

@ -5,6 +5,7 @@
#include "atom/browser/web_view_manager.h"
#include "atom/browser/atom_browser_context.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/web_contents.h"
@ -23,7 +24,7 @@ void WebViewManager::AddGuest(int guest_instance_id,
web_contents_embedder_map_[guest_instance_id] = { web_contents, embedder };
// Map the element in embedder to guest.
int owner_process_id = embedder->GetRenderProcessHost()->GetID();
int owner_process_id = embedder->GetMainFrame()->GetProcess()->GetID();
ElementInstanceKey key(owner_process_id, element_instance_id);
element_instance_id_to_guest_map_[key] = guest_instance_id;
}

10
atom/common/api/atom_api_native_image.cc
View file

@ -221,7 +221,7 @@ NativeImage::NativeImage(v8::Isolate* isolate, const gfx::Image& image)
Init(isolate);
if (image_.HasRepresentation(gfx::Image::kImageRepSkia)) {
isolate->AdjustAmountOfExternalAllocatedMemory(
image_.ToImageSkia()->bitmap()->computeSize64());
image_.ToImageSkia()->bitmap()->computeByteSize());
}
MarkHighMemoryUsage();
}
@ -236,7 +236,7 @@ NativeImage::NativeImage(v8::Isolate* isolate, const base::FilePath& hicon_path)
Init(isolate);
if (image_.HasRepresentation(gfx::Image::kImageRepSkia)) {
isolate->AdjustAmountOfExternalAllocatedMemory(
image_.ToImageSkia()->bitmap()->computeSize64());
image_.ToImageSkia()->bitmap()->computeByteSize());
}
MarkHighMemoryUsage();
}
@ -245,7 +245,7 @@ NativeImage::NativeImage(v8::Isolate* isolate, const base::FilePath& hicon_path)
NativeImage::~NativeImage() {
if (image_.HasRepresentation(gfx::Image::kImageRepSkia)) {
isolate()->AdjustAmountOfExternalAllocatedMemory(
- image_.ToImageSkia()->bitmap()->computeSize64());
-static_cast<int64_t>(image_.ToImageSkia()->bitmap()->computeByteSize()));
}
}
@ -302,7 +302,7 @@ v8::Local<v8::Value> NativeImage::ToBitmap(mate::Arguments* args) {
return node::Buffer::New(args->isolate(), 0).ToLocalChecked();
return node::Buffer::Copy(args->isolate(),
reinterpret_cast<const char*>(ref->pixels()),
bitmap.getSafeSize()).ToLocalChecked();
bitmap.computeByteSize()).ToLocalChecked();
}
v8::Local<v8::Value> NativeImage::ToJPEG(v8::Isolate* isolate, int quality) {
@ -340,7 +340,7 @@ v8::Local<v8::Value> NativeImage::GetBitmap(mate::Arguments* args) {
return node::Buffer::New(args->isolate(), 0).ToLocalChecked();
return node::Buffer::New(args->isolate(),
reinterpret_cast<char*>(ref->pixels()),
bitmap.getSafeSize(),
bitmap.computeByteSize(),
&Noop,
nullptr).ToLocalChecked();
}

1
atom/common/api/event_emitter_caller.h
View file

@ -7,6 +7,7 @@
#include <vector>
#include "atom/common/native_mate_converters/string16_converter.h"
#include "native_mate/converter.h"
namespace mate {

28
atom/common/api/features.cc Normal file
View file

@ -0,0 +1,28 @@
// 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/common/node_includes.h"
#include "native_mate/dictionary.h"
namespace {
bool IsPDFViewerEnabled() {
#if defined(ENABLE_PDF_VIEWER)
return true;
#else
return false;
#endif
}
void Initialize(v8::Local<v8::Object> exports,
v8::Local<v8::Value> unused,
v8::Local<v8::Context> context,
void* priv) {
mate::Dictionary dict(context->GetIsolate(), exports);
dict.SetMethod("isPDFViewerEnabled", &IsPDFViewerEnabled);
}
} // namespace
NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_common_features, Initialize)

2
atom/common/atom_constants.cc
View file

@ -24,11 +24,13 @@ const char kSecureProtocolDescription[] =
"The connection to this site is using a strong protocol version "
"and cipher suite.";
#if defined(ENABLE_PDF_VIEWER)
const char kPdfPluginMimeType[] = "application/x-google-chrome-pdf";
const char kPdfPluginPath[] = "chrome://pdf-viewer/";
const char kPdfPluginSrc[] = "src";
const char kPdfViewerUIOrigin[] = "chrome://pdf-viewer/";
const char kPdfViewerUIHost[] = "pdf-viewer";
#endif // defined(ENABLE_PDF_VIEWER)
} // namespace atom

2
atom/common/atom_constants.h
View file

@ -20,6 +20,7 @@ extern const char kValidCertificateDescription[];
extern const char kSecureProtocol[];
extern const char kSecureProtocolDescription[];
#if defined(ENABLE_PDF_VIEWER)
// The MIME type used for the PDF plugin.
extern const char kPdfPluginMimeType[];
extern const char kPdfPluginPath[];
@ -28,6 +29,7 @@ extern const char kPdfPluginSrc[];
// Constants for PDF viewer webui.
extern const char kPdfViewerUIOrigin[];
extern const char kPdfViewerUIHost[];
#endif // defined(ENABLE_PDF_VIEWER)
} // namespace atom

2
atom/common/chrome_version.h
View file

@ -8,7 +8,7 @@
#ifndef ATOM_COMMON_CHROME_VERSION_H_
#define ATOM_COMMON_CHROME_VERSION_H_
#define CHROME_VERSION_STRING "62.0.3202.94"
#define CHROME_VERSION_STRING "63.0.3239.150"
#define CHROME_VERSION "v" CHROME_VERSION_STRING
#endif // ATOM_COMMON_CHROME_VERSION_H_

1
atom/common/mouse_util.h
View file

@ -18,7 +18,6 @@
#define IPC_MESSAGE_FORWARD_CODE(msg_class, obj, member_func, code) \
case msg_class::ID: { \
TRACK_RUN_IN_THIS_SCOPED_REGION(member_func); \
if (!msg_class::Dispatch(&ipc_message__, obj, this, param__, \
&member_func)) \
ipc_message__.set_dispatch_error(); \

22
atom/common/native_mate_converters/blink_converter.cc
View file

@ -305,13 +305,21 @@ bool Converter<blink::WebFloatPoint>::FromV8(
return dict.Get("x", &out->x) && dict.Get("y", &out->y);
}
bool Converter<blink::WebPoint>::FromV8(
v8::Isolate* isolate, v8::Local<v8::Value> val, blink::WebPoint* out) {
mate::Dictionary dict;
if (!ConvertFromV8(isolate, val, &dict))
return false;
return dict.Get("x", &out->x) && dict.Get("y", &out->y);
}
template<>
struct Converter<base::Optional<blink::WebPoint>> {
static bool FromV8(
v8::Isolate* isolate, v8::Local<v8::Value> val,
base::Optional<blink::WebPoint>* out) {
mate::Dictionary dict;
if (!ConvertFromV8(isolate, val, &dict))
return false;
blink::WebPoint point;
bool success = dict.Get("x", &point.x) && dict.Get("y", &point.y);
if (!success) return false;
out->emplace(point);
return true;
}
};
bool Converter<blink::WebSize>::FromV8(
v8::Isolate* isolate, v8::Local<v8::Value> val, blink::WebSize* out) {

1
atom/common/node_bindings.cc
View file

@ -53,6 +53,7 @@
V(atom_common_asar) \
V(atom_common_clipboard) \
V(atom_common_crash_reporter) \
V(atom_common_features) \
V(atom_common_native_image) \
V(atom_common_notification) \
V(atom_common_screen) \

16
atom/common/node_includes.h
View file

@ -11,6 +11,10 @@
#define BUILDING_NODE_EXTENSION
// The following define makes sure that we do not include the macros
// again. But we still need the tracing functions, so declaring them.
#define SRC_TRACING_TRACE_EVENT_H_
#undef ASSERT
#undef CHECK
#undef CHECK_EQ
@ -33,4 +37,16 @@
#include "vendor/node/src/node_internals.h"
#include "vendor/node/src/node_platform.h"
namespace node {
namespace tracing {
class TraceEventHelper {
public:
static v8::TracingController* GetTracingController();
static void SetTracingController(v8::TracingController* controller);
};
} // namespace tracing
} // namespace node
#endif // ATOM_COMMON_NODE_INCLUDES_H_

1
atom/renderer/api/atom_api_renderer_ipc.cc
View file

@ -10,7 +10,6 @@
#include "content/public/renderer/render_frame.h"
#include "native_mate/dictionary.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebView.h"
using content::RenderFrame;
using blink::WebLocalFrame;

3
atom/renderer/api/atom_api_web_frame.cc
View file

@ -167,9 +167,8 @@ void WebFrame::SetLayoutZoomLevelLimits(double min_level, double max_level) {
v8::Local<v8::Value> WebFrame::RegisterEmbedderCustomElement(
const base::string16& name, v8::Local<v8::Object> options) {
blink::WebExceptionCode c = 0;
return web_frame_->GetDocument().RegisterEmbedderCustomElement(
blink::WebString::FromUTF16(name), options, c);
blink::WebString::FromUTF16(name), options);
}
void WebFrame::RegisterElementResizeCallback(

2
atom/renderer/atom_render_frame_observer.cc
View file

@ -7,8 +7,6 @@
#include <string>
#include <vector>
#include "atom/common/native_mate_converters/string16_converter.h"
#include "atom/common/api/api_messages.h"
#include "atom/common/api/event_emitter_caller.h"
#include "atom/common/native_mate_converters/value_converter.h"

3
atom/renderer/atom_render_view_observer.cc
View file

@ -14,7 +14,8 @@ namespace atom {
AtomRenderViewObserver::AtomRenderViewObserver(content::RenderView* render_view)
: content::RenderViewObserver(render_view) {}
AtomRenderViewObserver::~AtomRenderViewObserver() {}
AtomRenderViewObserver::~AtomRenderViewObserver() {
}
bool AtomRenderViewObserver::OnMessageReceived(const IPC::Message& message) {
bool handled = true;

41
atom/renderer/atom_renderer_client.cc
View file

@ -10,7 +10,6 @@
#include "atom/common/api/atom_bindings.h"
#include "atom/common/api/event_emitter_caller.h"
#include "atom/common/asar/asar_util.h"
#include "atom/common/atom_constants.h"
#include "atom/common/node_bindings.h"
#include "atom/common/options_switches.h"
#include "atom/renderer/api/atom_api_renderer_ipc.h"
@ -64,21 +63,19 @@ void AtomRendererClient::RenderViewCreated(content::RenderView* render_view) {
void AtomRendererClient::RunScriptsAtDocumentStart(
content::RenderFrame* render_frame) {
// Inform the document start pharse.
node::Environment* env = node_bindings_->uv_env();
if (env) {
v8::HandleScope handle_scope(env->isolate());
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
node::Environment* env = GetEnvironment(render_frame);
if (env)
mate::EmitEvent(env->isolate(), env->process_object(), "document-start");
}
}
void AtomRendererClient::RunScriptsAtDocumentEnd(
content::RenderFrame* render_frame) {
// Inform the document end pharse.
node::Environment* env = node_bindings_->uv_env();
if (env) {
v8::HandleScope handle_scope(env->isolate());
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
node::Environment* env = GetEnvironment(render_frame);
if (env)
mate::EmitEvent(env->isolate(), env->process_object(), "document-end");
}
}
void AtomRendererClient::DidCreateScriptContext(
@ -88,6 +85,8 @@ void AtomRendererClient::DidCreateScriptContext(
if (!render_frame->IsMainFrame() && !IsDevToolsExtension(render_frame))
return;
injected_frames_.insert(render_frame);
// Prepare the node bindings.
if (!node_integration_initialized_) {
node_integration_initialized_ = true;
@ -102,6 +101,7 @@ void AtomRendererClient::DidCreateScriptContext(
// Setup node environment for each window.
node::Environment* env = node_bindings_->CreateEnvironment(context);
environments_.insert(env);
// Add Electron extended APIs.
atom_bindings_->BindTo(env->isolate(), env->process_object());
@ -121,14 +121,14 @@ void AtomRendererClient::DidCreateScriptContext(
void AtomRendererClient::WillReleaseScriptContext(
v8::Handle<v8::Context> context, content::RenderFrame* render_frame) {
// Only allow node integration for the main frame, unless it is a devtools
// extension page.
if (!render_frame->IsMainFrame() && !IsDevToolsExtension(render_frame))
return;
injected_frames_.erase(render_frame);
node::Environment* env = node::Environment::GetCurrent(context);
if (env)
mate::EmitEvent(env->isolate(), env->process_object(), "exit");
if (environments_.find(env) == environments_.end())
return;
environments_.erase(env);
mate::EmitEvent(env->isolate(), env->process_object(), "exit");
// The main frame may be replaced.
if (env == node_bindings_->uv_env())
@ -209,5 +209,16 @@ void AtomRendererClient::SetupMainWorldOverrides(
ignore_result(func->Call(context, v8::Null(isolate), 1, args));
}
node::Environment* AtomRendererClient::GetEnvironment(
content::RenderFrame* render_frame) const {
if (injected_frames_.find(render_frame) == injected_frames_.end())
return nullptr;
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
node::Environment* env = node::Environment::GetCurrent(
render_frame->GetWebFrame()->MainWorldScriptContext());
if (environments_.find(env) == environments_.end())
return nullptr;
return env;
}
} // namespace atom

17
atom/renderer/atom_renderer_client.h
View file

@ -5,11 +5,16 @@
#ifndef ATOM_RENDERER_ATOM_RENDERER_CLIENT_H_
#define ATOM_RENDERER_ATOM_RENDERER_CLIENT_H_
#include <set>
#include <string>
#include <vector>
#include "atom/renderer/renderer_client_base.h"
namespace node {
class Environment;
}
namespace atom {
class AtomBindings;
@ -54,12 +59,24 @@ class AtomRendererClient : public RendererClientBase {
void WillDestroyWorkerContextOnWorkerThread(
v8::Local<v8::Context> context) override;
node::Environment* GetEnvironment(content::RenderFrame* frame) const;
// Whether the node integration has been initialized.
bool node_integration_initialized_;
std::unique_ptr<NodeBindings> node_bindings_;
std::unique_ptr<AtomBindings> atom_bindings_;
// The node::Environment::GetCurrent API does not return nullptr when it
// is called for a context without node::Environment, so we have to keep
// a book of the environments created.
std::set<node::Environment*> environments_;
// Getting main script context from web frame would lazily initializes
// its script context. Doing so in a web page without scripts would trigger
// assertion, so we have to keep a book of injected web frames.
std::set<content::RenderFrame*> injected_frames_;
DISALLOW_COPY_AND_ASSIGN(AtomRendererClient);
};

9
atom/renderer/renderer_client_base.cc
View file

@ -7,7 +7,6 @@
#include <string>
#include <vector>
#include "atom/common/atom_constants.h"
#include "atom/common/color_util.h"
#include "atom/common/native_mate_converters/value_converter.h"
#include "atom/common/options_switches.h"
@ -44,6 +43,10 @@
#include <shlobj.h>
#endif
#if defined(ENABLE_PDF_VIEWER)
#include "atom/common/atom_constants.h"
#endif // defined(ENABLE_PDF_VIEWER)
namespace atom {
namespace {
@ -153,9 +156,11 @@ void RendererClientBase::RenderFrameCreated(
// This is required for widevine plugin detection provided during runtime.
blink::ResetPluginCache();
#if defined(ENABLE_PDF_VIEWER)
// Allow access to file scheme from pdf viewer.
blink::WebSecurityPolicy::AddOriginAccessWhitelistEntry(
GURL(kPdfViewerUIOrigin), "file", "", true);
#endif // defined(ENABLE_PDF_VIEWER)
}
void RendererClientBase::RenderViewCreated(content::RenderView* render_view) {
@ -192,7 +197,9 @@ bool RendererClientBase::OverrideCreatePlugin(
blink::WebPlugin** plugin) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
if (params.mime_type.Utf8() == content::kBrowserPluginMimeType ||
#if defined(ENABLE_PDF_VIEWER)
params.mime_type.Utf8() == kPdfPluginMimeType ||
#endif // defined(ENABLE_PDF_VIEWER)
command_line->HasSwitch(switches::kEnablePlugins))
return false;

15
brightray/brightray.gyp
View file

@ -111,7 +111,7 @@
'<(libchromiumcontent_dir)/libdom_keycode_converter.a',
'<(libchromiumcontent_dir)/libsystem_wrappers.a',
'<(libchromiumcontent_dir)/librtc_base.a',
'<(libchromiumcontent_dir)/librtc_base_approved.a',
'<(libchromiumcontent_dir)/librtc_base_generic.a',
'<(libchromiumcontent_dir)/libwebrtc_common.a',
'<(libchromiumcontent_dir)/libinit_webrtc.a',
'<(libchromiumcontent_dir)/libyuv.a',
@ -129,7 +129,6 @@
'<(libchromiumcontent_dir)/libpdf.a',
'<(libchromiumcontent_dir)/libppapi_cpp_objects.a',
'<(libchromiumcontent_dir)/libppapi_internal_module.a',
'<(libchromiumcontent_dir)/libjpeg.a',
'<(libchromiumcontent_dir)/libpdfium.a',
'<(libchromiumcontent_dir)/libfdrm.a',
'<(libchromiumcontent_dir)/libformfiller.a',
@ -167,6 +166,9 @@
}],
['target_arch=="arm"', {
'link_settings': {
'libraries': [
'<(libchromiumcontent_dir)/libjpeg.a',
],
'libraries!': [
'<(libchromiumcontent_dir)/libdesktop_capture_differ_sse2.a',
],
@ -194,7 +196,7 @@
'<(libchromiumcontent_dir)/libdesktop_capture.a',
'<(libchromiumcontent_dir)/libdom_keycode_converter.a',
'<(libchromiumcontent_dir)/librtc_base.a',
'<(libchromiumcontent_dir)/librtc_base_approved.a',
'<(libchromiumcontent_dir)/librtc_base_generic.a',
'<(libchromiumcontent_dir)/libsystem_wrappers.a',
'<(libchromiumcontent_dir)/libwebrtc_common.a',
'<(libchromiumcontent_dir)/libinit_webrtc.a',
@ -278,6 +280,10 @@
'link_settings': {
'msvs_settings': {
'VCLinkerTool': {
'AdditionalOptions': [
# warning /DELAYLOAD:dll ignored; no imports found from dll
'/ignore:4199',
],
'AdditionalDependencies': [
'delayimp.lib',
],
@ -328,7 +334,7 @@
'<(libchromiumcontent_dir)/desktop_capture.lib',
'<(libchromiumcontent_dir)/dom_keycode_converter.lib',
'<(libchromiumcontent_dir)/rtc_base.lib',
'<(libchromiumcontent_dir)/rtc_base_approved.lib',
'<(libchromiumcontent_dir)/rtc_base_generic.lib',
'<(libchromiumcontent_dir)/system_wrappers.lib',
'<(libchromiumcontent_dir)/webrtc_common.lib',
'<(libchromiumcontent_dir)/init_webrtc.lib',
@ -393,6 +399,7 @@
'dbghelp.lib',
'dwmapi.lib',
'gdi32.lib',
'hid.lib',
'netapi32.lib',
'oleacc.lib',
'user32.lib',

8
brightray/brightray.gypi
View file

@ -142,6 +142,11 @@
'-Wl,-z,noexecstack',
],
}], # OS=="linux"
['OS=="linux" and target_arch in ["ia32", "x64", "arm64"]', {
'ldflags': [
'-fuse-ld=lld', # Chromium Clang uses lld for linking
],
}], # OS=="linux" and target_arch in ["ia32", "x64", "arm64"]
['OS=="mac"', {
'defines': [
# The usage of "webrtc/modules/desktop_capture/desktop_capture_options.h"
@ -293,7 +298,6 @@
],
'ldflags': [
'-flto=thin',
'-fuse-ld=lld', # Chromium Clang uses lld for doing LTO
'-Wl,--icf=all',
'-Wl,--lto-O0', # this could be removed in future; see https://codereview.chromium.org/2939923004
'-Wl,-mllvm,-function-sections',
@ -375,6 +379,7 @@
'-Wno-undefined-var-template', # https://crbug.com/604888
'-Wno-unneeded-internal-declaration',
'-Wno-inconsistent-missing-override',
'-Wno-tautological-unsigned-enum-zero-compare',
],
},
}],
@ -382,6 +387,7 @@
'cflags': [
'-Wno-inconsistent-missing-override',
'-Wno-undefined-var-template', # https://crbug.com/604888
'-Wno-tautological-unsigned-enum-zero-compare',
],
}],
['OS=="win"', {

10
brightray/browser/browser_context.cc
View file

@ -65,7 +65,7 @@ scoped_refptr<BrowserContext> BrowserContext::Get(
const std::string& partition, bool in_memory) {
PartitionKey key(partition, in_memory);
if (browser_context_map_[key].get())
return make_scoped_refptr(browser_context_map_[key].get());
return WrapRefCounted(browser_context_map_[key].get());
return nullptr;
}
@ -108,7 +108,7 @@ void BrowserContext::InitPrefs() {
pref_store->ReadPrefs(); // Synchronous.
prefs_factory.set_user_prefs(pref_store);
auto registry = make_scoped_refptr(new PrefRegistrySimple);
auto registry = WrapRefCounted(new PrefRegistrySimple);
RegisterInternalPrefs(registry.get());
RegisterPrefs(registry.get());
@ -132,7 +132,6 @@ net::URLRequestContextGetter* BrowserContext::CreateRequestContext(
DCHECK(!url_request_getter_.get());
url_request_getter_ = new URLRequestContextGetter(
this,
network_controller_handle(),
static_cast<NetLog*>(BrowserClient::Get()->GetNetLog()),
GetPath(),
in_memory_,
@ -199,6 +198,11 @@ content::PermissionManager* BrowserContext::GetPermissionManager() {
return permission_manager_.get();
}
content::BackgroundFetchDelegate*
BrowserContext::GetBackgroundFetchDelegate() {
return nullptr;
}
content::BackgroundSyncController*
BrowserContext::GetBackgroundSyncController() {
return nullptr;

8
brightray/browser/browser_context.h
View file

@ -11,7 +11,6 @@
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "brightray/browser/media/media_device_id_salt.h"
#include "brightray/browser/net/devtools_network_controller_handle.h"
#include "brightray/browser/permission_manager.h"
#include "brightray/browser/url_request_context_getter.h"
#include "content/public/browser/browser_context.h"
@ -54,6 +53,7 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
content::PushMessagingService* GetPushMessagingService() override;
content::SSLHostStateDelegate* GetSSLHostStateDelegate() override;
content::PermissionManager* GetPermissionManager() override;
content::BackgroundFetchDelegate* GetBackgroundFetchDelegate() override;
content::BackgroundSyncController* GetBackgroundSyncController() override;
content::BrowsingDataRemoverDelegate* GetBrowsingDataRemoverDelegate()
override;
@ -75,10 +75,6 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
return url_request_getter_.get();
}
DevToolsNetworkControllerHandle* network_controller_handle() {
return &network_controller_handle_;
}
void InitPrefs();
PrefService* prefs() { return prefs_.get(); }
@ -125,8 +121,6 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
base::FilePath path_;
bool in_memory_;
DevToolsNetworkControllerHandle network_controller_handle_;
std::unique_ptr<ResourceContext> resource_context_;
scoped_refptr<URLRequestContextGetter> url_request_getter_;
scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;

3
brightray/browser/browser_main_parts.cc
View file

@ -186,7 +186,8 @@ void OverrideAppLogsPath() {
void BrowserMainParts::PreEarlyInitialization() {
std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
feature_list->InitializeFromCommandLine("", "");
// TODO(deepak1556): Disable guest webcontents based on OOPIF feature.
feature_list->InitializeFromCommandLine("", "GuestViewCrossProcessFrames");
base::FeatureList::SetInstance(std::move(feature_list));
OverrideAppLogsPath();
#if defined(USE_X11)

2
brightray/browser/browser_main_parts.h
View file

@ -35,6 +35,8 @@ class BrowserMainParts : public content::BrowserMainParts {
BrowserMainParts();
~BrowserMainParts();
IOThread* io_thread() const { return io_thread_.get(); }
protected:
// content::BrowserMainParts:
void PreEarlyInitialization() override;

10
brightray/browser/devtools_manager_delegate.cc
View file

@ -12,7 +12,6 @@
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "brightray/browser/net/devtools_network_protocol_handler.h"
#include "brightray/common/content_client.h"
#include "content/public/browser/devtools_agent_host.h"
#include "content/public/browser/devtools_frontend_host.h"
@ -93,9 +92,7 @@ void DevToolsManagerDelegate::StartHttpHandler() {
base::FilePath());
}
DevToolsManagerDelegate::DevToolsManagerDelegate()
: handler_(new DevToolsNetworkProtocolHandler) {
}
DevToolsManagerDelegate::DevToolsManagerDelegate() {}
DevToolsManagerDelegate::~DevToolsManagerDelegate() {
}
@ -103,10 +100,11 @@ DevToolsManagerDelegate::~DevToolsManagerDelegate() {
void DevToolsManagerDelegate::Inspect(content::DevToolsAgentHost* agent_host) {
}
base::DictionaryValue* DevToolsManagerDelegate::HandleCommand(
bool DevToolsManagerDelegate::HandleCommand(
content::DevToolsAgentHost* agent_host,
int session_id,
base::DictionaryValue* command) {
return handler_->HandleCommand(agent_host, command);
return false;
}
scoped_refptr<content::DevToolsAgentHost>

7
brightray/browser/devtools_manager_delegate.h
View file

@ -13,8 +13,6 @@
namespace brightray {
class DevToolsNetworkProtocolHandler;
class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
public:
static void StartHttpHandler();
@ -24,8 +22,9 @@ class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
// DevToolsManagerDelegate implementation.
void Inspect(content::DevToolsAgentHost* agent_host) override;
base::DictionaryValue* HandleCommand(
bool HandleCommand(
content::DevToolsAgentHost* agent_host,
int session_id,
base::DictionaryValue* command) override;
scoped_refptr<content::DevToolsAgentHost> CreateNewTarget(
const GURL& url) override;
@ -33,8 +32,6 @@ class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
std::string GetFrontendResource(const std::string& path) override;
private:
std::unique_ptr<DevToolsNetworkProtocolHandler> handler_;
DISALLOW_COPY_AND_ASSIGN(DevToolsManagerDelegate);
};

7
brightray/browser/io_thread.cc
View file

@ -8,6 +8,7 @@
#include "net/proxy/proxy_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"
#if defined(USE_NSS_CERTS)
#include "net/cert_net/nss_ocsp.h"
@ -28,8 +29,10 @@ IOThread::~IOThread() {
void IOThread::Init() {
net::URLRequestContextBuilder builder;
builder.set_proxy_service(net::ProxyService::CreateDirect());
builder.DisableHttpCache();
url_request_context_ = builder.Build();
url_request_context_getter_ = new net::TrivialURLRequestContextGetter(
url_request_context_.get(), base::ThreadTaskRunnerHandle::Get());
url_request_context_getter_->AddRef();
#if defined(USE_NSS_CERTS)
net::SetMessageLoopForNSSHttpIO();
@ -42,6 +45,8 @@ void IOThread::CleanUp() {
net::ShutdownNSSHttpIO();
net::SetURLRequestContextForNSSHttpIO(nullptr);
#endif
// Explicitly release before the IO thread gets destroyed.
url_request_context_getter_->Release();
url_request_context_.reset();
}

6
brightray/browser/io_thread.h
View file

@ -12,6 +12,7 @@
namespace net {
class URLRequestContext;
class URLRequestContextGetter;
}
namespace brightray {
@ -21,6 +22,10 @@ class IOThread : public content::BrowserThreadDelegate {
IOThread();
~IOThread() override;
net::URLRequestContextGetter* GetRequestContext() {
return url_request_context_getter_;
}
protected:
// BrowserThreadDelegate Implementation, runs on the IO thread.
void Init() override;
@ -28,6 +33,7 @@ class IOThread : public content::BrowserThreadDelegate {
private:
std::unique_ptr<net::URLRequestContext> url_request_context_;
net::URLRequestContextGetter* url_request_context_getter_;
DISALLOW_COPY_AND_ASSIGN(IOThread);
};

35
brightray/browser/net/devtools_network_conditions.cc
View file

@ -1,35 +0,0 @@
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "brightray/browser/net/devtools_network_conditions.h"
namespace brightray {
DevToolsNetworkConditions::DevToolsNetworkConditions(bool offline)
: offline_(offline),
latency_(0),
download_throughput_(0),
upload_throughput_(0) {
}
DevToolsNetworkConditions::DevToolsNetworkConditions(
bool offline,
double latency,
double download_throughput,
double upload_throughput)
: offline_(offline),
latency_(latency),
download_throughput_(download_throughput),
upload_throughput_(upload_throughput) {
}
DevToolsNetworkConditions::~DevToolsNetworkConditions() {
}
bool DevToolsNetworkConditions::IsThrottling() const {
return !offline_ && ((latency_ != 0.0) || (download_throughput_ != 0.0) ||
(upload_throughput_ != 0.0));
}
} // namespace brightray

39
brightray/browser/net/devtools_network_conditions.h
View file

@ -1,39 +0,0 @@
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONDITIONS_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONDITIONS_H_
#include "base/macros.h"
namespace brightray {
class DevToolsNetworkConditions {
public:
explicit DevToolsNetworkConditions(bool offline);
DevToolsNetworkConditions(bool offline,
double latency,
double download_throughput,
double upload_throughput);
~DevToolsNetworkConditions();
bool IsThrottling() const;
bool offline() const { return offline_; }
double latency() const { return latency_; }
double download_throughput() const { return download_throughput_; }
double upload_throughput() const { return upload_throughput_; }
private:
const bool offline_;
const double latency_;
const double download_throughput_;
const double upload_throughput_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkConditions);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONDITIONS_H_

78
brightray/browser/net/devtools_network_controller.cc
View file

@ -1,78 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#include "brightray/browser/net/devtools_network_controller.h"
#include "base/bind.h"
#include "brightray/browser/net/devtools_network_conditions.h"
#include "brightray/browser/net/devtools_network_interceptor.h"
#include "brightray/browser/net/devtools_network_transaction.h"
#include "content/public/browser/browser_thread.h"
using content::BrowserThread;
namespace brightray {
DevToolsNetworkController::DevToolsNetworkController()
: appcache_interceptor_(new DevToolsNetworkInterceptor) {
}
DevToolsNetworkController::~DevToolsNetworkController() {
}
void DevToolsNetworkController::SetNetworkState(
const std::string& client_id,
std::unique_ptr<DevToolsNetworkConditions> conditions) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
auto it = interceptors_.find(client_id);
if (it == interceptors_.end()) {
if (!conditions)
return;
std::unique_ptr<DevToolsNetworkInterceptor> new_interceptor(
new DevToolsNetworkInterceptor);
new_interceptor->UpdateConditions(std::move(conditions));
interceptors_[client_id] = std::move(new_interceptor);
} else {
if (!conditions) {
std::unique_ptr<DevToolsNetworkConditions> online_conditions(
new DevToolsNetworkConditions(false));
it->second->UpdateConditions(std::move(online_conditions));
interceptors_.erase(client_id);
} else {
it->second->UpdateConditions(std::move(conditions));
}
}
bool has_offline_interceptors = false;
for (const auto& interceptor : interceptors_) {
if (interceptor.second->IsOffline()) {
has_offline_interceptors = true;
break;
}
}
bool is_appcache_offline = appcache_interceptor_->IsOffline();
if (is_appcache_offline != has_offline_interceptors) {
std::unique_ptr<DevToolsNetworkConditions> appcache_conditions(
new DevToolsNetworkConditions(has_offline_interceptors));
appcache_interceptor_->UpdateConditions(std::move(appcache_conditions));
}
}
DevToolsNetworkInterceptor*
DevToolsNetworkController::GetInterceptor(const std::string& client_id) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (interceptors_.empty() || client_id.empty())
return nullptr;
auto it = interceptors_.find(client_id);
if (it == interceptors_.end())
return nullptr;
return it->second.get();
}
} // namespace brightray

44
brightray/browser/net/devtools_network_controller.h
View file

@ -1,44 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_H_
#include <memory>
#include <string>
#include <unordered_map>
#include "base/macros.h"
#include "base/threading/thread_checker.h"
namespace brightray {
class DevToolsNetworkConditions;
class DevToolsNetworkInterceptor;
class DevToolsNetworkTransaction;
class DevToolsNetworkController {
public:
DevToolsNetworkController();
virtual ~DevToolsNetworkController();
void SetNetworkState(const std::string& client_id,
std::unique_ptr<DevToolsNetworkConditions> conditions);
DevToolsNetworkInterceptor* GetInterceptor(const std::string& client_id);
private:
using InterceptorMap =
std::unordered_map<std::string,
std::unique_ptr<DevToolsNetworkInterceptor>>;
std::unique_ptr<DevToolsNetworkInterceptor> appcache_interceptor_;
InterceptorMap interceptors_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkController);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_H_

60
brightray/browser/net/devtools_network_controller_handle.cc
View file

@ -1,60 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#include "brightray/browser/net/devtools_network_controller_handle.h"
#include "base/bind.h"
#include "brightray/browser/net/devtools_network_conditions.h"
#include "brightray/browser/net/devtools_network_controller.h"
#include "content/public/browser/browser_thread.h"
using content::BrowserThread;
namespace brightray {
DevToolsNetworkControllerHandle::DevToolsNetworkControllerHandle() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
}
DevToolsNetworkControllerHandle::~DevToolsNetworkControllerHandle() {
BrowserThread::DeleteSoon(BrowserThread::IO,
FROM_HERE,
controller_.release());
}
void DevToolsNetworkControllerHandle::SetNetworkState(
const std::string& client_id,
std::unique_ptr<DevToolsNetworkConditions> conditions) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&DevToolsNetworkControllerHandle::SetNetworkStateOnIO,
base::Unretained(this), client_id, base::Passed(&conditions)));
}
DevToolsNetworkController* DevToolsNetworkControllerHandle::GetController() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
LazyInitialize();
return controller_.get();
}
void DevToolsNetworkControllerHandle::LazyInitialize() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!controller_)
controller_.reset(new DevToolsNetworkController);
}
void DevToolsNetworkControllerHandle::SetNetworkStateOnIO(
const std::string& client_id,
std::unique_ptr<DevToolsNetworkConditions> conditions) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
LazyInitialize();
controller_->SetNetworkState(client_id, std::move(conditions));
}
} // namespace brightray

45
brightray/browser/net/devtools_network_controller_handle.h
View file

@ -1,45 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_
#include <memory>
#include <string>
#include "base/macros.h"
namespace brightray {
class DevToolsNetworkConditions;
class DevToolsNetworkController;
// A handle to manage an IO-thread DevToolsNetworkController on the IO thread
// while allowing SetNetworkState to be called from the UI thread.
class DevToolsNetworkControllerHandle {
public:
DevToolsNetworkControllerHandle();
~DevToolsNetworkControllerHandle();
// Called on the UI thread.
void SetNetworkState(const std::string& client_id,
std::unique_ptr<DevToolsNetworkConditions> conditions);
// Called on the IO thread.
DevToolsNetworkController* GetController();
private:
void LazyInitialize();
void SetNetworkStateOnIO(
const std::string& client_id,
std::unique_ptr<DevToolsNetworkConditions> conditions);
std::unique_ptr<DevToolsNetworkController> controller_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkControllerHandle);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_

293
brightray/browser/net/devtools_network_interceptor.cc
View file

@ -1,293 +0,0 @@
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "brightray/browser/net/devtools_network_interceptor.h"
#include <algorithm>
#include <limits>
#include "base/time/time.h"
#include "brightray/browser/net/devtools_network_conditions.h"
#include "net/base/net_errors.h"
namespace brightray {
namespace {
int64_t kPacketSize = 1500;
base::TimeDelta CalculateTickLength(double throughput) {
if (!throughput)
return base::TimeDelta();
int64_t us_tick_length = (1000000L * kPacketSize) / throughput;
if (us_tick_length == 0)
us_tick_length = 1;
return base::TimeDelta::FromMicroseconds(us_tick_length);
}
} // namespace
DevToolsNetworkInterceptor::ThrottleRecord::ThrottleRecord() {
}
DevToolsNetworkInterceptor::ThrottleRecord::ThrottleRecord(
const ThrottleRecord& other) = default;
DevToolsNetworkInterceptor::ThrottleRecord::~ThrottleRecord() {
}
DevToolsNetworkInterceptor::DevToolsNetworkInterceptor()
: conditions_(new DevToolsNetworkConditions(false)),
download_last_tick_(0),
upload_last_tick_(0),
weak_ptr_factory_(this) {
}
DevToolsNetworkInterceptor::~DevToolsNetworkInterceptor() {
}
base::WeakPtr<DevToolsNetworkInterceptor>
DevToolsNetworkInterceptor::GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
void DevToolsNetworkInterceptor::FinishRecords(
ThrottleRecords* records, bool offline) {
ThrottleRecords temp;
temp.swap(*records);
for (const ThrottleRecord& record : temp) {
bool failed = offline && !record.is_upload;
record.callback.Run(
failed ? net::ERR_INTERNET_DISCONNECTED : record.result,
record.bytes);
}
}
void DevToolsNetworkInterceptor::UpdateConditions(
std::unique_ptr<DevToolsNetworkConditions> conditions) {
DCHECK(conditions);
base::TimeTicks now = base::TimeTicks::Now();
if (conditions_->IsThrottling())
UpdateThrottled(now);
conditions_ = std::move(conditions);
bool offline = conditions_->offline();
if (offline || !conditions_->IsThrottling()) {
timer_.Stop();
FinishRecords(&download_, offline);
FinishRecords(&upload_, offline);
FinishRecords(&suspended_, offline);
return;
}
// Throttling.
DCHECK(conditions_->download_throughput() != 0 ||
conditions_->upload_throughput() != 0);
offset_ = now;
download_last_tick_ = 0;
download_tick_length_ = CalculateTickLength(
conditions_->download_throughput());
upload_last_tick_ = 0;
upload_tick_length_ = CalculateTickLength(conditions_->upload_throughput());
latency_length_ = base::TimeDelta();
double latency = conditions_->latency();
if (latency > 0)
latency_length_ = base::TimeDelta::FromMillisecondsD(latency);
ArmTimer(now);
}
uint64_t DevToolsNetworkInterceptor::UpdateThrottledRecords(
base::TimeTicks now,
ThrottleRecords* records,
uint64_t last_tick,
base::TimeDelta tick_length) {
if (tick_length.is_zero()) {
DCHECK(records->empty());
return last_tick;
}
int64_t new_tick = (now - offset_) / tick_length;
int64_t ticks = new_tick - last_tick;
int64_t length = records->size();
if (!length)
return new_tick;
int64_t shift = ticks % length;
for (int64_t i = 0; i < length; ++i) {
(*records)[i].bytes -=
(ticks / length) * kPacketSize + (i < shift ? kPacketSize : 0);
}
std::rotate(records->begin(), records->begin() + shift, records->end());
return new_tick;
}
void DevToolsNetworkInterceptor::UpdateThrottled(base::TimeTicks now) {
download_last_tick_ = UpdateThrottledRecords(
now, &download_, download_last_tick_, download_tick_length_);
upload_last_tick_ = UpdateThrottledRecords(
now, &upload_, upload_last_tick_, upload_tick_length_);
UpdateSuspended(now);
}
void DevToolsNetworkInterceptor::UpdateSuspended(base::TimeTicks now) {
int64_t activation_baseline =
(now - latency_length_ - base::TimeTicks()).InMicroseconds();
ThrottleRecords suspended;
for (const ThrottleRecord& record : suspended_) {
if (record.send_end <= activation_baseline) {
if (record.is_upload)
upload_.push_back(record);
else
download_.push_back(record);
} else {
suspended.push_back(record);
}
}
suspended_.swap(suspended);
}
void DevToolsNetworkInterceptor::CollectFinished(
ThrottleRecords* records, ThrottleRecords* finished) {
ThrottleRecords active;
for (const ThrottleRecord& record : *records) {
if (record.bytes < 0)
finished->push_back(record);
else
active.push_back(record);
}
records->swap(active);
}
void DevToolsNetworkInterceptor::OnTimer() {
base::TimeTicks now = base::TimeTicks::Now();
UpdateThrottled(now);
ThrottleRecords finished;
CollectFinished(&download_, &finished);
CollectFinished(&upload_, &finished);
for (const ThrottleRecord& record : finished)
record.callback.Run(record.result, record.bytes);
ArmTimer(now);
}
base::TimeTicks DevToolsNetworkInterceptor::CalculateDesiredTime(
const ThrottleRecords& records,
uint64_t last_tick,
base::TimeDelta tick_length) {
int64_t min_ticks_left = 0x10000L;
size_t count = records.size();
for (size_t i = 0; i < count; ++i) {
int64_t packets_left = (records[i].bytes + kPacketSize - 1) / kPacketSize;
int64_t ticks_left = (i + 1) + count * (packets_left - 1);
if (i == 0 || ticks_left < min_ticks_left)
min_ticks_left = ticks_left;
}
return offset_ + tick_length * (last_tick + min_ticks_left);
}
void DevToolsNetworkInterceptor::ArmTimer(base::TimeTicks now) {
size_t suspend_count = suspended_.size();
if (download_.empty() && upload_.empty() && !suspend_count) {
timer_.Stop();
return;
}
base::TimeTicks desired_time = CalculateDesiredTime(
download_, download_last_tick_, download_tick_length_);
if (desired_time == offset_) {
FinishRecords(&download_, false);
}
base::TimeTicks upload_time = CalculateDesiredTime(
upload_, upload_last_tick_, upload_tick_length_);
if (upload_time != offset_ && upload_time < desired_time)
desired_time = upload_time;
int64_t min_baseline = std::numeric_limits<int64_t>::max();
for (size_t i = 0; i < suspend_count; ++i) {
if (suspended_[i].send_end < min_baseline)
min_baseline = suspended_[i].send_end;
}
if (suspend_count) {
base::TimeTicks activation_time = base::TimeTicks() +
base::TimeDelta::FromMicroseconds(min_baseline) + latency_length_;
if (activation_time < desired_time)
desired_time = activation_time;
}
timer_.Start(
FROM_HERE, (desired_time - now).magnitude(),
base::Bind(&DevToolsNetworkInterceptor::OnTimer, base::Unretained(this)));
}
int DevToolsNetworkInterceptor::StartThrottle(
int result,
int64_t bytes,
base::TimeTicks send_end,
bool start,
bool is_upload,
const ThrottleCallback& callback) {
if (result < 0)
return result;
if (conditions_->offline())
return is_upload ? result : net::ERR_INTERNET_DISCONNECTED;
if ((is_upload && !conditions_->upload_throughput()) ||
(!is_upload && !conditions_->download_throughput())) {
return result;
}
ThrottleRecord record;
record.result = result;
record.bytes = bytes;
record.callback = callback;
record.is_upload = is_upload;
base::TimeTicks now = base::TimeTicks::Now();
UpdateThrottled(now);
if (start && latency_length_ != base::TimeDelta()) {
record.send_end = (send_end - base::TimeTicks()).InMicroseconds();
suspended_.push_back(record);
UpdateSuspended(now);
} else {
if (is_upload)
upload_.push_back(record);
else
download_.push_back(record);
}
ArmTimer(now);
return net::ERR_IO_PENDING;
}
void DevToolsNetworkInterceptor::StopThrottle(
const ThrottleCallback& callback) {
RemoveRecord(&download_, callback);
RemoveRecord(&upload_, callback);
RemoveRecord(&suspended_, callback);
}
void DevToolsNetworkInterceptor::RemoveRecord(
ThrottleRecords* records, const ThrottleCallback& callback) {
records->erase(
std::remove_if(records->begin(), records->end(),
[&callback](const ThrottleRecord& record){
return record.callback.Equals(callback);
}),
records->end());
}
bool DevToolsNetworkInterceptor::IsOffline() {
return conditions_->offline();
}
} // namespace brightray

107
brightray/browser/net/devtools_network_interceptor.h
View file

@ -1,107 +0,0 @@
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_INTERCEPTOR_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_INTERCEPTOR_H_
#include <string>
#include <utility>
#include <vector>
#include "base/macros.h"
#include "base/timer/timer.h"
namespace base {
class TimeDelta;
class TimeTicks;
}
namespace brightray {
class DevToolsNetworkConditions;
class DevToolsNetworkTransaction;
class DevToolsNetworkInterceptor {
public:
using ThrottleCallback = base::Callback<void(int, int64_t)>;
DevToolsNetworkInterceptor();
virtual ~DevToolsNetworkInterceptor();
base::WeakPtr<DevToolsNetworkInterceptor> GetWeakPtr();
// Applies network emulation configuration.
void UpdateConditions(std::unique_ptr<DevToolsNetworkConditions> conditions);
// Throttles with |is_upload == true| always succeed, even in offline mode.
int StartThrottle(int result,
int64_t bytes,
base::TimeTicks send_end,
bool start,
bool is_upload,
const ThrottleCallback& callback);
void StopThrottle(const ThrottleCallback& callback);
bool IsOffline();
private:
struct ThrottleRecord {
public:
ThrottleRecord();
ThrottleRecord(const ThrottleRecord& other);
~ThrottleRecord();
int result;
int64_t bytes;
int64_t send_end;
bool is_upload;
ThrottleCallback callback;
};
using ThrottleRecords = std::vector<ThrottleRecord>;
void FinishRecords(ThrottleRecords* records, bool offline);
uint64_t UpdateThrottledRecords(base::TimeTicks now,
ThrottleRecords* records,
uint64_t last_tick,
base::TimeDelta tick_length);
void UpdateThrottled(base::TimeTicks now);
void UpdateSuspended(base::TimeTicks now);
void CollectFinished(ThrottleRecords* records, ThrottleRecords* finished);
void OnTimer();
base::TimeTicks CalculateDesiredTime(const ThrottleRecords& records,
uint64_t last_tick,
base::TimeDelta tick_length);
void ArmTimer(base::TimeTicks now);
void RemoveRecord(ThrottleRecords* records, const ThrottleCallback& callback);
std::unique_ptr<DevToolsNetworkConditions> conditions_;
// Throttables suspended for a "latency" period.
ThrottleRecords suspended_;
// Throttables waiting for certain amount of transfer to be "accounted".
ThrottleRecords download_;
ThrottleRecords upload_;
base::OneShotTimer timer_;
base::TimeTicks offset_;
base::TimeDelta download_tick_length_;
base::TimeDelta upload_tick_length_;
base::TimeDelta latency_length_;
uint64_t download_last_tick_;
uint64_t upload_last_tick_;
base::WeakPtrFactory<DevToolsNetworkInterceptor> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkInterceptor);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_INTERCEPTOR_H_

173
brightray/browser/net/devtools_network_protocol_handler.cc
View file

@ -1,173 +0,0 @@
// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#include "brightray/browser/net/devtools_network_protocol_handler.h"
#include <string>
#include <utility>
#include "base/memory/ptr_util.h"
#include "base/strings/stringprintf.h"
#include "brightray/browser/browser_context.h"
#include "brightray/browser/net/devtools_network_conditions.h"
#include "brightray/browser/net/devtools_network_controller.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/devtools_agent_host.h"
namespace brightray {
namespace {
namespace params {
const char kDownloadThroughput[] = "downloadThroughput";
const char kLatency[] = "latency";
const char kOffline[] = "offline";
const char kUploadThroughput[] = "uploadThroughput";
const char kResult[] = "result";
const char kErrorCode[] = "code";
const char kErrorMessage[] = "message";
} // namespace params
const char kEmulateNetworkConditions[] = "Network.emulateNetworkConditions";
const char kCanEmulateNetworkConditions[] =
"Network.canEmulateNetworkConditions";
const char kId[] = "id";
const char kMethod[] = "method";
const char kParams[] = "params";
const char kError[] = "error";
// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
const int kErrorInvalidParams = -32602;
bool ParseCommand(const base::DictionaryValue* command,
int* id,
std::string* method,
const base::DictionaryValue** params) {
if (!command)
return false;
if (!command->GetInteger(kId, id) || *id < 0)
return false;
if (!command->GetString(kMethod, method))
return false;
if (!command->GetDictionary(kParams, params))
*params = nullptr;
return true;
}
std::unique_ptr<base::DictionaryValue>
CreateSuccessResponse(int id, std::unique_ptr<base::DictionaryValue> result) {
auto response = base::MakeUnique<base::DictionaryValue>();
response->SetInteger(kId, id);
response->Set(params::kResult, std::move(result));
return response;
}
std::unique_ptr<base::DictionaryValue>
CreateFailureResponse(int id, const std::string& param) {
auto response = base::MakeUnique<base::DictionaryValue>();
auto error_object = base::MakeUnique<base::DictionaryValue>();
error_object->SetInteger(params::kErrorCode, kErrorInvalidParams);
error_object->SetString(params::kErrorMessage,
base::StringPrintf("Missing or Invalid '%s' parameter", param.c_str()));
response->Set(kError, std::move(error_object));
return response;
}
} // namespace
DevToolsNetworkProtocolHandler::DevToolsNetworkProtocolHandler() {
}
DevToolsNetworkProtocolHandler::~DevToolsNetworkProtocolHandler() {
}
base::DictionaryValue* DevToolsNetworkProtocolHandler::HandleCommand(
content::DevToolsAgentHost* agent_host,
base::DictionaryValue* command) {
int id = 0;
std::string method;
const base::DictionaryValue* params = nullptr;
if (!ParseCommand(command, &id, &method, &params))
return nullptr;
if (method == kEmulateNetworkConditions)
return EmulateNetworkConditions(agent_host, id, params).release();
if (method == kCanEmulateNetworkConditions)
return CanEmulateNetworkConditions(agent_host, id, params).release();
return nullptr;
}
void DevToolsNetworkProtocolHandler::DevToolsAgentStateChanged(
content::DevToolsAgentHost* agent_host,
bool attached) {
std::unique_ptr<DevToolsNetworkConditions> conditions;
if (attached)
conditions.reset(new DevToolsNetworkConditions(false));
UpdateNetworkState(agent_host, std::move(conditions));
}
std::unique_ptr<base::DictionaryValue>
DevToolsNetworkProtocolHandler::CanEmulateNetworkConditions(
content::DevToolsAgentHost* agent_host,
int id,
const base::DictionaryValue* params) {
std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
result->SetBoolean(params::kResult, true);
return CreateSuccessResponse(id, std::move(result));
}
std::unique_ptr<base::DictionaryValue>
DevToolsNetworkProtocolHandler::EmulateNetworkConditions(
content::DevToolsAgentHost* agent_host,
int id,
const base::DictionaryValue* params) {
bool offline = false;
if (!params || !params->GetBoolean(params::kOffline, &offline))
return CreateFailureResponse(id, params::kOffline);
double latency = 0.0;
if (!params->GetDouble(params::kLatency, &latency))
return CreateFailureResponse(id, params::kLatency);
if (latency < 0.0)
latency = 0.0;
double download_throughput = 0.0;
if (!params->GetDouble(params::kDownloadThroughput, &download_throughput))
return CreateFailureResponse(id, params::kDownloadThroughput);
if (download_throughput < 0.0)
download_throughput = 0.0;
double upload_throughput = 0.0;
if (!params->GetDouble(params::kUploadThroughput, &upload_throughput))
return CreateFailureResponse(id, params::kUploadThroughput);
if (upload_throughput < 0.0)
upload_throughput = 0.0;
std::unique_ptr<DevToolsNetworkConditions> conditions(
new DevToolsNetworkConditions(offline,
latency,
download_throughput,
upload_throughput));
UpdateNetworkState(agent_host, std::move(conditions));
return std::unique_ptr<base::DictionaryValue>();
}
void DevToolsNetworkProtocolHandler::UpdateNetworkState(
content::DevToolsAgentHost* agent_host,
std::unique_ptr<DevToolsNetworkConditions> conditions) {
auto browser_context =
static_cast<brightray::BrowserContext*>(agent_host->GetBrowserContext());
browser_context->network_controller_handle()->SetNetworkState(
agent_host->GetId(), std::move(conditions));
}
} // namespace brightray

48
brightray/browser/net/devtools_network_protocol_handler.h
View file

@ -1,48 +0,0 @@
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_
#include "base/macros.h"
#include "base/values.h"
namespace content {
class DevToolsAgentHost;
}
namespace brightray {
class DevToolsNetworkConditions;
class DevToolsNetworkProtocolHandler {
public:
DevToolsNetworkProtocolHandler();
~DevToolsNetworkProtocolHandler();
base::DictionaryValue* HandleCommand(
content::DevToolsAgentHost* agent_host,
base::DictionaryValue* command);
void DevToolsAgentStateChanged(content::DevToolsAgentHost* agent_host,
bool attached);
private:
std::unique_ptr<base::DictionaryValue> CanEmulateNetworkConditions(
content::DevToolsAgentHost* agent_host,
int command_id,
const base::DictionaryValue* params);
std::unique_ptr<base::DictionaryValue> EmulateNetworkConditions(
content::DevToolsAgentHost* agent_host,
int command_id,
const base::DictionaryValue* params);
void UpdateNetworkState(
content::DevToolsAgentHost* agent_host,
std::unique_ptr<DevToolsNetworkConditions> conditions);
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkProtocolHandler);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_

302
brightray/browser/net/devtools_network_transaction.cc
View file

@ -1,302 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#include "brightray/browser/net/devtools_network_transaction.h"
#include <string>
#include <utility>
#include "brightray/browser/net/devtools_network_controller.h"
#include "brightray/browser/net/devtools_network_upload_data_stream.h"
#include "net/base/load_timing_info.h"
#include "net/base/net_errors.h"
#include "net/base/upload_progress.h"
#include "net/http/http_network_transaction.h"
#include "net/http/http_request_info.h"
#include "net/socket/connection_attempts.h"
namespace brightray {
// static
const char
DevToolsNetworkTransaction::kDevToolsEmulateNetworkConditionsClientId[] =
"X-DevTools-Emulate-Network-Conditions-Client-Id";
DevToolsNetworkTransaction::DevToolsNetworkTransaction(
DevToolsNetworkController* controller,
std::unique_ptr<net::HttpTransaction> transaction)
: throttled_byte_count_(0),
controller_(controller),
transaction_(std::move(transaction)),
request_(nullptr),
failed_(false) {
DCHECK(controller);
}
DevToolsNetworkTransaction::~DevToolsNetworkTransaction() {
if (interceptor_ && !throttle_callback_.is_null())
interceptor_->StopThrottle(throttle_callback_);
}
void DevToolsNetworkTransaction::IOCallback(
const net::CompletionCallback& callback, bool start, int result) {
result = Throttle(callback, start, result);
if (result != net::ERR_IO_PENDING)
callback.Run(result);
}
int DevToolsNetworkTransaction::Throttle(
const net::CompletionCallback& callback, bool start, int result) {
if (failed_)
return net::ERR_INTERNET_DISCONNECTED;
if (!interceptor_ || result < 0)
return result;
base::TimeTicks send_end;
if (start) {
throttled_byte_count_ += transaction_->GetTotalReceivedBytes();
net::LoadTimingInfo load_timing_info;
if (GetLoadTimingInfo(&load_timing_info))
send_end = load_timing_info.send_end;
if (send_end.is_null())
send_end = base::TimeTicks::Now();
}
if (result > 0)
throttled_byte_count_ += result;
throttle_callback_ = base::Bind(&DevToolsNetworkTransaction::ThrottleCallback,
base::Unretained(this),
callback);
int rv = interceptor_->StartThrottle(result, throttled_byte_count_, send_end,
start, false, throttle_callback_);
if (rv != net::ERR_IO_PENDING)
throttle_callback_.Reset();
if (rv == net::ERR_INTERNET_DISCONNECTED)
Fail();
return rv;
}
void DevToolsNetworkTransaction::ThrottleCallback(
const net::CompletionCallback& callback, int result, int64_t bytes) {
DCHECK(!throttle_callback_.is_null());
throttle_callback_.Reset();
if (result == net::ERR_INTERNET_DISCONNECTED)
Fail();
throttled_byte_count_ = bytes;
callback.Run(result);
}
void DevToolsNetworkTransaction::Fail() {
DCHECK(request_);
DCHECK(!failed_);
failed_ = true;
transaction_->SetBeforeNetworkStartCallback(BeforeNetworkStartCallback());
if (interceptor_)
interceptor_.reset();
}
bool DevToolsNetworkTransaction::CheckFailed() {
if (failed_)
return true;
if (interceptor_ && interceptor_->IsOffline()) {
Fail();
return true;
}
return false;
}
int DevToolsNetworkTransaction::Start(const net::HttpRequestInfo* request,
const net::CompletionCallback& callback,
const net::NetLogWithSource& net_log) {
DCHECK(request);
request_ = request;
std::string client_id;
bool has_devtools_client_id = request_->extra_headers.HasHeader(
kDevToolsEmulateNetworkConditionsClientId);
if (has_devtools_client_id) {
custom_request_.reset(new net::HttpRequestInfo(*request_));
custom_request_->extra_headers.GetHeader(
kDevToolsEmulateNetworkConditionsClientId, &client_id);
custom_request_->extra_headers.RemoveHeader(
kDevToolsEmulateNetworkConditionsClientId);
if (request_->upload_data_stream) {
custom_upload_data_stream_.reset(
new DevToolsNetworkUploadDataStream(request_->upload_data_stream));
custom_request_->upload_data_stream = custom_upload_data_stream_.get();
}
request_ = custom_request_.get();
}
DevToolsNetworkInterceptor* interceptor =
controller_->GetInterceptor(client_id);
if (interceptor) {
interceptor_ = interceptor->GetWeakPtr();
if (custom_upload_data_stream_)
custom_upload_data_stream_->SetInterceptor(interceptor);
}
if (CheckFailed())
return net::ERR_INTERNET_DISCONNECTED;
if (!interceptor_)
return transaction_->Start(request_, callback, net_log);
int result = transaction_->Start(request_,
base::Bind(&DevToolsNetworkTransaction::IOCallback,
base::Unretained(this), callback, true),
net_log);
return Throttle(callback, true, result);
}
int DevToolsNetworkTransaction::RestartIgnoringLastError(
const net::CompletionCallback& callback) {
if (CheckFailed())
return net::ERR_INTERNET_DISCONNECTED;
if (!interceptor_)
return transaction_->RestartIgnoringLastError(callback);
int result = transaction_->RestartIgnoringLastError(
base::Bind(&DevToolsNetworkTransaction::IOCallback,
base::Unretained(this), callback, true));
return Throttle(callback, true, result);
}
int DevToolsNetworkTransaction::RestartWithCertificate(
scoped_refptr<net::X509Certificate> client_cert,
scoped_refptr<net::SSLPrivateKey> client_private_key,
const net::CompletionCallback& callback) {
if (CheckFailed())
return net::ERR_INTERNET_DISCONNECTED;
if (!interceptor_) {
return transaction_->RestartWithCertificate(
std::move(client_cert), std::move(client_private_key), callback);
}
int result = transaction_->RestartWithCertificate(
std::move(client_cert), std::move(client_private_key),
base::Bind(&DevToolsNetworkTransaction::IOCallback,
base::Unretained(this), callback, true));
return Throttle(callback, true, result);
}
int DevToolsNetworkTransaction::RestartWithAuth(
const net::AuthCredentials& credentials,
const net::CompletionCallback& callback) {
if (CheckFailed())
return net::ERR_INTERNET_DISCONNECTED;
if (!interceptor_)
return transaction_->RestartWithAuth(credentials, callback);
int result = transaction_->RestartWithAuth(credentials,
base::Bind(&DevToolsNetworkTransaction::IOCallback,
base::Unretained(this), callback, true));
return Throttle(callback, true, result);
}
bool DevToolsNetworkTransaction::IsReadyToRestartForAuth() {
return transaction_->IsReadyToRestartForAuth();
}
int DevToolsNetworkTransaction::Read(
net::IOBuffer* buf,
int buf_len,
const net::CompletionCallback& callback) {
if (CheckFailed())
return net::ERR_INTERNET_DISCONNECTED;
if (!interceptor_)
return transaction_->Read(buf, buf_len, callback);
int result = transaction_->Read(buf, buf_len,
base::Bind(&DevToolsNetworkTransaction::IOCallback,
base::Unretained(this), callback, false));
// URLRequestJob relies on synchronous end-of-stream notification.
if (result == 0)
return result;
return Throttle(callback, false, result);
}
void DevToolsNetworkTransaction::StopCaching() {
transaction_->StopCaching();
}
bool DevToolsNetworkTransaction::GetFullRequestHeaders(
net::HttpRequestHeaders* headers) const {
return transaction_->GetFullRequestHeaders(headers);
}
int64_t DevToolsNetworkTransaction::GetTotalReceivedBytes() const {
return transaction_->GetTotalReceivedBytes();
}
int64_t DevToolsNetworkTransaction::GetTotalSentBytes() const {
return transaction_->GetTotalSentBytes();
}
void DevToolsNetworkTransaction::DoneReading() {
transaction_->DoneReading();
}
const net::HttpResponseInfo*
DevToolsNetworkTransaction::GetResponseInfo() const {
return transaction_->GetResponseInfo();
}
net::LoadState DevToolsNetworkTransaction::GetLoadState() const {
return transaction_->GetLoadState();
}
void DevToolsNetworkTransaction::SetQuicServerInfo(
net::QuicServerInfo* info) {
transaction_->SetQuicServerInfo(info);
}
bool DevToolsNetworkTransaction::GetLoadTimingInfo(
net::LoadTimingInfo* info) const {
return transaction_->GetLoadTimingInfo(info);
}
bool DevToolsNetworkTransaction::GetRemoteEndpoint(
net::IPEndPoint* endpoint) const {
return transaction_->GetRemoteEndpoint(endpoint);
}
void DevToolsNetworkTransaction::PopulateNetErrorDetails(
net::NetErrorDetails* details) const {
return transaction_->PopulateNetErrorDetails(details);
}
void DevToolsNetworkTransaction::SetPriority(net::RequestPriority priority) {
transaction_->SetPriority(priority);
}
void DevToolsNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper(
net::WebSocketHandshakeStreamBase::CreateHelper* helper) {
transaction_->SetWebSocketHandshakeStreamCreateHelper(helper);
}
void DevToolsNetworkTransaction::SetBeforeNetworkStartCallback(
const BeforeNetworkStartCallback& callback) {
transaction_->SetBeforeNetworkStartCallback(callback);
}
void DevToolsNetworkTransaction::SetBeforeHeadersSentCallback(
const BeforeHeadersSentCallback& callback) {
transaction_->SetBeforeHeadersSentCallback(callback);
}
int DevToolsNetworkTransaction::ResumeNetworkStart() {
if (CheckFailed())
return net::ERR_INTERNET_DISCONNECTED;
return transaction_->ResumeNetworkStart();
}
void DevToolsNetworkTransaction::GetConnectionAttempts(
net::ConnectionAttempts* out) const {
transaction_->GetConnectionAttempts(out);
}
} // namespace brightray

113
brightray/browser/net/devtools_network_transaction.h
View file

@ -1,113 +0,0 @@
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_H_
#include <stdint.h>
#include "base/memory/weak_ptr.h"
#include "brightray/browser/net/devtools_network_interceptor.h"
#include "net/base/completion_callback.h"
#include "net/base/load_states.h"
#include "net/base/request_priority.h"
#include "net/http/http_raw_request_headers.h"
#include "net/http/http_transaction.h"
namespace brightray {
class DevToolsNetworkController;
class DevToolsNetworkUploadDataStream;
class DevToolsNetworkTransaction : public net::HttpTransaction {
public:
static const char kDevToolsEmulateNetworkConditionsClientId[];
DevToolsNetworkTransaction(
DevToolsNetworkController* controller,
std::unique_ptr<net::HttpTransaction> network_transaction);
~DevToolsNetworkTransaction() override;
// HttpTransaction methods:
int Start(const net::HttpRequestInfo* request,
const net::CompletionCallback& callback,
const net::NetLogWithSource& net_log) override;
int RestartIgnoringLastError(
const net::CompletionCallback& callback) override;
int RestartWithCertificate(
scoped_refptr<net::X509Certificate> client_cert,
scoped_refptr<net::SSLPrivateKey> client_private_key,
const net::CompletionCallback& callback) override;
int RestartWithAuth(const net::AuthCredentials& credentials,
const net::CompletionCallback& callback) override;
bool IsReadyToRestartForAuth() override;
int Read(net::IOBuffer* buf,
int buf_len,
const net::CompletionCallback& callback) override;
void StopCaching() override;
bool GetFullRequestHeaders(net::HttpRequestHeaders* headers) const override;
int64_t GetTotalReceivedBytes() const override;
int64_t GetTotalSentBytes() const override;
void DoneReading() override;
const net::HttpResponseInfo* GetResponseInfo() const override;
net::LoadState GetLoadState() const override;
void SetQuicServerInfo(net::QuicServerInfo* quic_server_info) override;
bool GetLoadTimingInfo(net::LoadTimingInfo* load_timing_info) const override;
bool GetRemoteEndpoint(net::IPEndPoint* endpoint) const override;
void PopulateNetErrorDetails(net::NetErrorDetails* details) const override;
void SetPriority(net::RequestPriority priority) override;
void SetWebSocketHandshakeStreamCreateHelper(
net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) override;
void SetBeforeNetworkStartCallback(
const BeforeNetworkStartCallback& callback) override;
void SetBeforeHeadersSentCallback(
const BeforeHeadersSentCallback& callback) override;
int ResumeNetworkStart() override;
void GetConnectionAttempts(net::ConnectionAttempts* out) const override;
// FIXME(torycl) Implement these methods properly
void SetRequestHeadersCallback(net::RequestHeadersCallback callback) {}
void SetResponseHeadersCallback(net::ResponseHeadersCallback callback) {}
private:
void Fail();
bool CheckFailed();
void IOCallback(const net::CompletionCallback& callback,
bool start,
int result);
int Throttle(const net::CompletionCallback& callback,
bool start,
int result);
void ThrottleCallback(const net::CompletionCallback& callback,
int result,
int64_t bytes);
DevToolsNetworkInterceptor::ThrottleCallback throttle_callback_;
int64_t throttled_byte_count_;
DevToolsNetworkController* controller_;
base::WeakPtr<DevToolsNetworkInterceptor> interceptor_;
// Modified upload data stream. Should be destructed after |custom_request_|.
std::unique_ptr<DevToolsNetworkUploadDataStream> custom_upload_data_stream_;
// Modified request. Should be destructed after |transaction_|.
std::unique_ptr<net::HttpRequestInfo> custom_request_;
// Original network transaction.
std::unique_ptr<net::HttpTransaction> transaction_;
const net::HttpRequestInfo* request_;
// True if Fail was already invoked.
bool failed_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransaction);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_H_

53
brightray/browser/net/devtools_network_transaction_factory.cc
View file

@ -1,53 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#include "brightray/browser/net/devtools_network_transaction_factory.h"
#include <set>
#include <string>
#include "brightray/browser/net/devtools_network_controller.h"
#include "brightray/browser/net/devtools_network_transaction.h"
#include "content/public/browser/service_worker_context.h"
#include "net/base/net_errors.h"
#include "net/http/http_network_layer.h"
#include "net/http/http_network_transaction.h"
namespace brightray {
DevToolsNetworkTransactionFactory::DevToolsNetworkTransactionFactory(
DevToolsNetworkController* controller,
net::HttpNetworkSession* session)
: controller_(controller),
network_layer_(new net::HttpNetworkLayer(session)) {
std::set<std::string> headers;
headers.insert(
DevToolsNetworkTransaction::kDevToolsEmulateNetworkConditionsClientId);
content::ServiceWorkerContext::AddExcludedHeadersForFetchEvent(headers);
}
DevToolsNetworkTransactionFactory::~DevToolsNetworkTransactionFactory() {
}
int DevToolsNetworkTransactionFactory::CreateTransaction(
net::RequestPriority priority,
std::unique_ptr<net::HttpTransaction>* transaction) {
std::unique_ptr<net::HttpTransaction> new_transaction;
int rv = network_layer_->CreateTransaction(priority, &new_transaction);
if (rv != net::OK)
return rv;
transaction->reset(
new DevToolsNetworkTransaction(controller_, std::move(new_transaction)));
return net::OK;
}
net::HttpCache* DevToolsNetworkTransactionFactory::GetCache() {
return network_layer_->GetCache();
}
net::HttpNetworkSession* DevToolsNetworkTransactionFactory::GetSession() {
return network_layer_->GetSession();
}
} // namespace brightray

39
brightray/browser/net/devtools_network_transaction_factory.h
View file

@ -1,39 +0,0 @@
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
#include "base/macros.h"
#include "net/base/request_priority.h"
#include "net/http/http_transaction_factory.h"
namespace brightray {
class DevToolsNetworkController;
class DevToolsNetworkTransactionFactory : public net::HttpTransactionFactory {
public:
explicit DevToolsNetworkTransactionFactory(
DevToolsNetworkController* controller,
net::HttpNetworkSession* session);
~DevToolsNetworkTransactionFactory() override;
// net::HttpTransactionFactory:
int CreateTransaction(
net::RequestPriority priority,
std::unique_ptr<net::HttpTransaction>* transaction) override;
net::HttpCache* GetCache() override;
net::HttpNetworkSession* GetSession() override;
private:
DevToolsNetworkController* controller_;
std::unique_ptr<net::HttpTransactionFactory> network_layer_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransactionFactory);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_

96
brightray/browser/net/devtools_network_upload_data_stream.cc
View file

@ -1,96 +0,0 @@
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "brightray/browser/net/devtools_network_upload_data_stream.h"
#include "net/base/net_errors.h"
namespace brightray {
DevToolsNetworkUploadDataStream::DevToolsNetworkUploadDataStream(
net::UploadDataStream* upload_data_stream)
: net::UploadDataStream(upload_data_stream->is_chunked(),
upload_data_stream->identifier()),
throttle_callback_(
base::Bind(&DevToolsNetworkUploadDataStream::ThrottleCallback,
base::Unretained(this))),
throttled_byte_count_(0),
upload_data_stream_(upload_data_stream) {
}
DevToolsNetworkUploadDataStream::~DevToolsNetworkUploadDataStream() {
if (interceptor_)
interceptor_->StopThrottle(throttle_callback_);
}
void DevToolsNetworkUploadDataStream::SetInterceptor(
DevToolsNetworkInterceptor* interceptor) {
DCHECK(!interceptor_);
if (interceptor)
interceptor_ = interceptor->GetWeakPtr();
}
bool DevToolsNetworkUploadDataStream::IsInMemory() const {
return false;
}
int DevToolsNetworkUploadDataStream::InitInternal(
const net::NetLogWithSource& net_log) {
throttled_byte_count_ = 0;
int result = upload_data_stream_->Init(
base::Bind(&DevToolsNetworkUploadDataStream::StreamInitCallback,
base::Unretained(this)),
net_log);
if (result == net::OK && !is_chunked())
SetSize(upload_data_stream_->size());
return result;
}
void DevToolsNetworkUploadDataStream::StreamInitCallback(int result) {
if (!is_chunked())
SetSize(upload_data_stream_->size());
OnInitCompleted(result);
}
int DevToolsNetworkUploadDataStream::ReadInternal(
net::IOBuffer* buf, int buf_len) {
int result = upload_data_stream_->Read(buf, buf_len,
base::Bind(&DevToolsNetworkUploadDataStream::StreamReadCallback,
base::Unretained(this)));
return ThrottleRead(result);
}
void DevToolsNetworkUploadDataStream::StreamReadCallback(int result) {
result = ThrottleRead(result);
if (result != net::ERR_IO_PENDING)
OnReadCompleted(result);
}
int DevToolsNetworkUploadDataStream::ThrottleRead(int result) {
if (is_chunked() && upload_data_stream_->IsEOF())
SetIsFinalChunk();
if (!interceptor_ || result < 0)
return result;
if (result > 0)
throttled_byte_count_ += result;
return interceptor_->StartThrottle(result, throttled_byte_count_,
base::TimeTicks(), false, true, throttle_callback_);
}
void DevToolsNetworkUploadDataStream::ThrottleCallback(
int result, int64_t bytes) {
throttled_byte_count_ = bytes;
OnReadCompleted(result);
}
void DevToolsNetworkUploadDataStream::ResetInternal() {
upload_data_stream_->Reset();
throttled_byte_count_ = 0;
if (interceptor_)
interceptor_->StopThrottle(throttle_callback_);
}
} // namespace brightray

50
brightray/browser/net/devtools_network_upload_data_stream.h
View file

@ -1,50 +0,0 @@
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_UPLOAD_DATA_STREAM_H_
#define BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_UPLOAD_DATA_STREAM_H_
#include <stdint.h>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "brightray/browser/net/devtools_network_interceptor.h"
#include "net/base/upload_data_stream.h"
namespace brightray {
class DevToolsNetworkUploadDataStream : public net::UploadDataStream {
public:
// Supplied |upload_data_stream| must outlive this object.
explicit DevToolsNetworkUploadDataStream(
net::UploadDataStream* upload_data_stream);
~DevToolsNetworkUploadDataStream() override;
void SetInterceptor(DevToolsNetworkInterceptor* interceptor);
private:
// net::UploadDataStream implementation.
bool IsInMemory() const override;
int InitInternal(const net::NetLogWithSource& net_log) override;
int ReadInternal(net::IOBuffer* buf, int buf_len) override;
void ResetInternal() override;
void StreamInitCallback(int result);
void StreamReadCallback(int result);
int ThrottleRead(int result);
void ThrottleCallback(int result, int64_t bytes);
DevToolsNetworkInterceptor::ThrottleCallback throttle_callback_;
int64_t throttled_byte_count_;
net::UploadDataStream* upload_data_stream_;
base::WeakPtr<DevToolsNetworkInterceptor> interceptor_;
DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkUploadDataStream);
};
} // namespace brightray
#endif // BRIGHTRAY_BROWSER_NET_DEVTOOLS_NETWORK_UPLOAD_DATA_STREAM_H_

43
brightray/browser/url_request_context_getter.cc
View file

@ -10,11 +10,8 @@
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/threading/worker_pool.h"
#include "base/task_scheduler/post_task.h"
#include "brightray/browser/browser_client.h"
#include "brightray/browser/net/devtools_network_controller_handle.h"
#include "brightray/browser/net/devtools_network_transaction_factory.h"
#include "brightray/browser/net/require_ct_delegate.h"
#include "brightray/browser/net_log.h"
#include "brightray/browser/network_delegate.h"
@ -22,6 +19,7 @@
#include "components/network_session_configurator/common/network_switches.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/cookie_store_factory.h"
#include "content/public/browser/devtools_network_transaction_factory.h"
#include "content/public/common/content_switches.h"
#include "net/base/host_mapping_rules.h"
#include "net/cert/cert_verifier.h"
@ -40,7 +38,6 @@
#include "net/proxy/proxy_config_service.h"
#include "net/proxy/proxy_script_fetcher_impl.h"
#include "net/proxy/proxy_service.h"
#include "net/proxy/proxy_service_v8.h"
#include "net/ssl/channel_id_service.h"
#include "net/ssl/default_channel_id_store.h"
#include "net/ssl/ssl_config_service_defaults.h"
@ -79,9 +76,10 @@ URLRequestContextGetter::Delegate::CreateURLRequestJobFactory(
url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler));
job_factory->SetProtocolHandler(
url::kFileScheme,
base::WrapUnique(new net::FileProtocolHandler(
BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
base::WrapUnique(
new net::FileProtocolHandler(base::CreateTaskRunnerWithTraits(
{base::MayBlock(), base::TaskPriority::USER_VISIBLE,
base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}))));
return std::move(job_factory);
}
@ -120,7 +118,6 @@ URLRequestContextGetter::Delegate::GetCookieableSchemes() {
URLRequestContextGetter::URLRequestContextGetter(
Delegate* delegate,
DevToolsNetworkControllerHandle* handle,
NetLog* net_log,
const base::FilePath& base_path,
bool in_memory,
@ -128,7 +125,6 @@ URLRequestContextGetter::URLRequestContextGetter(
content::ProtocolHandlerMap* protocol_handlers,
content::URLRequestInterceptorScopedVector protocol_interceptors)
: delegate_(delegate),
network_controller_handle_(handle),
net_log_(net_log),
base_path_(base_path),
in_memory_(in_memory),
@ -230,7 +226,6 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
}
// --proxy-server
net::DhcpProxyScriptFetcherFactory dhcp_factory;
if (command_line.HasSwitch(switches::kNoProxyServer)) {
storage_->set_proxy_service(net::ProxyService::CreateDirect());
} else if (command_line.HasSwitch(switches::kProxyServer)) {
@ -248,13 +243,9 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
proxy_config));
} else {
storage_->set_proxy_service(
net::CreateProxyServiceUsingV8ProxyResolver(
net::ProxyService::CreateUsingSystemProxyResolver(
std::move(proxy_config_service_),
new net::ProxyScriptFetcherImpl(url_request_context_.get()),
dhcp_factory.Create(url_request_context_.get()),
host_resolver.get(),
nullptr,
url_request_context_->network_delegate()));
net_log_));
}
std::vector<std::string> schemes;
@ -339,20 +330,10 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
backend.reset(delegate_->CreateHttpCacheBackendFactory(base_path_));
}
if (network_controller_handle_) {
storage_->set_http_transaction_factory(base::WrapUnique(
new net::HttpCache(
base::WrapUnique(new DevToolsNetworkTransactionFactory(
network_controller_handle_->GetController(),
http_network_session_.get())),
std::move(backend),
false)));
} else {
storage_->set_http_transaction_factory(base::WrapUnique(
new net::HttpCache(http_network_session_.get(),
std::move(backend),
false)));
}
storage_->set_http_transaction_factory(base::MakeUnique<net::HttpCache>(
content::CreateDevToolsNetworkTransactionFactory(
http_network_session_.get()),
std::move(backend), false));
std::unique_ptr<net::URLRequestJobFactory> job_factory =
delegate_->CreateURLRequestJobFactory(&protocol_handlers_);

3
brightray/browser/url_request_context_getter.h
View file

@ -35,7 +35,6 @@ class URLRequestJobFactory;
namespace brightray {
class RequireCTDelegate;
class DevToolsNetworkControllerHandle;
class NetLog;
class URLRequestContextGetter : public net::URLRequestContextGetter {
@ -64,7 +63,6 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
URLRequestContextGetter(
Delegate* delegate,
DevToolsNetworkControllerHandle* handle,
NetLog* net_log,
const base::FilePath& base_path,
bool in_memory,
@ -88,7 +86,6 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
private:
Delegate* delegate_;
DevToolsNetworkControllerHandle* network_controller_handle_;
NetLog* net_log_;
base::FilePath base_path_;
bool in_memory_;

23
brightray/browser/views/views_delegate.cc
View file

@ -8,9 +8,26 @@
#include "ui/views/widget/native_widget_aura.h"
#if defined(OS_LINUX)
#include "base/environment.h"
#include "base/nix/xdg_util.h"
#include "ui/views/linux_ui/linux_ui.h"
#endif
namespace {
bool IsDesktopEnvironmentUnity() {
#if defined(OS_LINUX)
std::unique_ptr<base::Environment> env(base::Environment::Create());
base::nix::DesktopEnvironment desktop_env =
base::nix::GetDesktopEnvironment(env.get());
return desktop_env == base::nix::DESKTOP_ENVIRONMENT_UNITY;
#else
return false;
#endif
}
} // namespace
namespace brightray {
ViewsDelegate::ViewsDelegate() {
@ -104,8 +121,10 @@ bool ViewsDelegate::WindowManagerProvidesTitleBar(bool maximized) {
#if defined(OS_LINUX)
// On Ubuntu Unity, the system always provides a title bar for maximized
// windows.
views::LinuxUI* ui = views::LinuxUI::instance();
return maximized && ui && ui->UnityIsRunning();
if (!maximized)
return false;
static bool is_desktop_environment_unity = IsDesktopEnvironmentUnity();
return is_desktop_environment_unity;
#else
return false;
#endif

2
brightray/common/main_delegate.cc
View file

@ -62,9 +62,11 @@ void LoadResourceBundle(const std::string& locale) {
bundle.AddDataPackFromPath(
pak_dir.Append(FILE_PATH_LITERAL("content_shell.pak")),
ui::GetSupportedScaleFactors()[0]);
#if defined(ENABLE_PDF_VIEWER)
bundle.AddDataPackFromPath(
pak_dir.Append(FILE_PATH_LITERAL("pdf_viewer_resources.pak")),
ui::GetSupportedScaleFactors()[0]);
#endif // defined(ENABLE_PDF_VIEWER)
bundle.AddDataPackFromPath(pak_dir.Append(FILE_PATH_LITERAL(
"blink_image_resources_200_percent.pak")),
ui::SCALE_FACTOR_200P);

2
brightray/common/main_delegate_mac.mm
View file

@ -36,8 +36,10 @@ void LoadCommonResources() {
ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
bundle.AddDataPackFromPath(GetResourcesPakFilePath(@"content_shell"),
ui::GetSupportedScaleFactors()[0]);
#if defined(ENABLE_PDF_VIEWER)
bundle.AddDataPackFromPath(GetResourcesPakFilePath(@"pdf_viewer_resources"),
ui::GetSupportedScaleFactors()[0]);
#endif // defined(ENABLE_PDF_VIEWER)
}
void MainDelegate::OverrideFrameworkBundlePath() {

16
brightray/filenames.gypi
View file

@ -47,22 +47,6 @@
'browser/media/media_device_id_salt.h',
'browser/media/media_stream_devices_controller.cc',
'browser/media/media_stream_devices_controller.h',
'browser/net/devtools_network_conditions.cc',
'browser/net/devtools_network_conditions.h',
'browser/net/devtools_network_controller.cc',
'browser/net/devtools_network_controller.h',
'browser/net/devtools_network_controller_handle.cc',
'browser/net/devtools_network_controller_handle.h',
'browser/net/devtools_network_interceptor.cc',
'browser/net/devtools_network_interceptor.h',
'browser/net/devtools_network_protocol_handler.cc',
'browser/net/devtools_network_protocol_handler.h',
'browser/net/devtools_network_transaction_factory.cc',
'browser/net/devtools_network_transaction_factory.h',
'browser/net/devtools_network_transaction.cc',
'browser/net/devtools_network_transaction.h',
'browser/net/devtools_network_upload_data_stream.cc',
'browser/net/devtools_network_upload_data_stream.h',
'browser/net/require_ct_delegate.cc',
'browser/net/require_ct_delegate.h',
'browser/net_log.cc',

19
chromium_src/chrome/browser/certificate_manager_model.cc
View file

@ -91,11 +91,12 @@ CertificateManagerModel::CertificateManagerModel(
CertificateManagerModel::~CertificateManagerModel() {
}
int CertificateManagerModel::ImportFromPKCS12(PK11SlotInfo* slot_info,
const std::string& data,
const base::string16& password,
bool is_extractable,
net::CertificateList* imported_certs) {
int CertificateManagerModel::ImportFromPKCS12(
PK11SlotInfo* slot_info,
const std::string& data,
const base::string16& password,
bool is_extractable,
net::ScopedCERTCertificateList* imported_certs) {
return cert_db_->ImportFromPKCS12(slot_info, data, password,
is_extractable, imported_certs);
}
@ -105,14 +106,14 @@ int CertificateManagerModel::ImportUserCert(const std::string& data) {
}
bool CertificateManagerModel::ImportCACerts(
const net::CertificateList& certificates,
const net::ScopedCERTCertificateList& certificates,
net::NSSCertDatabase::TrustBits trust_bits,
net::NSSCertDatabase::ImportCertFailureList* not_imported) {
return cert_db_->ImportCACerts(certificates, trust_bits, not_imported);
}
bool CertificateManagerModel::ImportServerCert(
const net::CertificateList& certificates,
const net::ScopedCERTCertificateList& certificates,
net::NSSCertDatabase::TrustBits trust_bits,
net::NSSCertDatabase::ImportCertFailureList* not_imported) {
return cert_db_->ImportServerCert(certificates, trust_bits,
@ -120,13 +121,13 @@ bool CertificateManagerModel::ImportServerCert(
}
bool CertificateManagerModel::SetCertTrust(
const net::X509Certificate* cert,
CERTCertificate* cert,
net::CertType type,
net::NSSCertDatabase::TrustBits trust_bits) {
return cert_db_->SetCertTrust(cert, type, trust_bits);
}
bool CertificateManagerModel::Delete(net::X509Certificate* cert) {
bool CertificateManagerModel::Delete(CERTCertificate* cert) {
return cert_db_->DeleteCertAndKey(cert);
}

10
chromium_src/chrome/browser/certificate_manager_model.h
View file

@ -48,7 +48,7 @@ class CertificateManagerModel {
const std::string& data,
const base::string16& password,
bool is_extractable,
net::CertificateList* imported_certs);
net::ScopedCERTCertificateList* imported_certs);
// Import user certificate from DER encoded |data|.
// Returns a net error code on failure.
@ -62,7 +62,7 @@ class CertificateManagerModel {
// Returns false if there is an internal error, otherwise true is returned and
// |not_imported| should be checked for any certificates that were not
// imported.
bool ImportCACerts(const net::CertificateList& certificates,
bool ImportCACerts(const net::ScopedCERTCertificateList& certificates,
net::NSSCertDatabase::TrustBits trust_bits,
net::NSSCertDatabase::ImportCertFailureList* not_imported);
@ -77,20 +77,20 @@ class CertificateManagerModel {
// |not_imported| should be checked for any certificates that were not
// imported.
bool ImportServerCert(
const net::CertificateList& certificates,
const net::ScopedCERTCertificateList& certificates,
net::NSSCertDatabase::TrustBits trust_bits,
net::NSSCertDatabase::ImportCertFailureList* not_imported);
// Set trust values for certificate.
// |trust_bits| should be a bit field of TRUST* values from NSSCertDatabase.
// Returns true on success or false on failure.
bool SetCertTrust(const net::X509Certificate* cert,
bool SetCertTrust(CERTCertificate* cert,
net::CertType type,
net::NSSCertDatabase::TrustBits trust_bits);
// Delete the cert. Returns true on success. |cert| is still valid when this
// function returns.
bool Delete(net::X509Certificate* cert);
bool Delete(CERTCertificate* cert);
private:
CertificateManagerModel(net::NSSCertDatabase* nss_cert_database,

9
chromium_src/chrome/browser/media/native_desktop_media_list.cc
View file

@ -14,7 +14,7 @@ using base::PlatformThreadRef;
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/task_scheduler/post_task.h"
#include "chrome/browser/media/desktop_media_list_observer.h"
#include "content/public/browser/browser_thread.h"
#include "media/base/video_util.h"
@ -37,7 +37,7 @@ const int kDefaultUpdatePeriod = 1000;
// media source has changed.
uint32_t GetFrameHash(webrtc::DesktopFrame* frame) {
int data_size = frame->stride() * frame->size().height();
return base::SuperFastHash(reinterpret_cast<char*>(frame->data()), data_size);
return base::Hash(frame->data(), data_size);
}
gfx::ImageSkia ScaleDesktopFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
@ -235,9 +235,8 @@ NativeDesktopMediaList::NativeDesktopMediaList(
view_dialog_id_(-1),
observer_(NULL),
weak_factory_(this) {
base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
capture_task_runner_ = worker_pool->GetSequencedTaskRunner(
worker_pool->GetSequenceToken());
capture_task_runner_ = base::CreateSequencedTaskRunnerWithTraits(
{base::MayBlock(), base::TaskPriority::USER_VISIBLE});
}
NativeDesktopMediaList::~NativeDesktopMediaList() {

26
chromium_src/chrome/browser/printing/print_job.cc
View file

@ -13,11 +13,11 @@
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/task_scheduler/post_task.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/threading/thread_restrictions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/threading/worker_pool.h"
#include "build/build_config.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/printing/print_job_worker.h"
@ -45,8 +45,7 @@ void HoldRefCallback(const scoped_refptr<PrintJobWorkerOwner>& owner,
} // namespace
PrintJob::PrintJob()
: source_(nullptr),
is_job_pending_(false),
: is_job_pending_(false),
is_canceling_(false),
quit_factory_(this) {
// This is normally a UI message loop, but in unit tests, the message loop is
@ -65,19 +64,17 @@ PrintJob::~PrintJob() {
}
void PrintJob::Initialize(PrintJobWorkerOwner* job,
PrintedPagesSource* source,
const base::string16& name,
int page_count) {
DCHECK(!source_);
DCHECK(!worker_);
DCHECK(!is_job_pending_);
DCHECK(!is_canceling_);
DCHECK(!document_.get());
source_ = source;
worker_ = job->DetachWorker(this);
settings_ = job->settings();
PrintedDocument* new_doc =
new PrintedDocument(settings_, source_, job->cookie());
new PrintedDocument(settings_, name, job->cookie());
new_doc->set_page_count(page_count);
UpdatePrintedDocument(new_doc);
@ -126,7 +123,7 @@ void PrintJob::StartPrinting() {
// Real work is done in PrintJobWorker::StartPrinting().
worker_->PostTask(FROM_HERE,
base::Bind(&HoldRefCallback, make_scoped_refptr(this),
base::Bind(&HoldRefCallback, WrapRefCounted(this),
base::Bind(&PrintJobWorker::StartPrinting,
base::Unretained(worker_.get()),
base::RetainedRef(document_))));
@ -204,12 +201,6 @@ bool PrintJob::FlushJob(base::TimeDelta timeout) {
return true;
}
void PrintJob::DisconnectSource() {
source_ = nullptr;
if (document_.get())
document_->DisconnectSource();
}
bool PrintJob::is_job_pending() const {
return is_job_pending_;
}
@ -349,7 +340,7 @@ void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
DCHECK(!is_job_pending_);
// Sync the document with the worker.
worker_->PostTask(FROM_HERE,
base::Bind(&HoldRefCallback, make_scoped_refptr(this),
base::Bind(&HoldRefCallback, WrapRefCounted(this),
base::Bind(&PrintJobWorker::OnDocumentChanged,
base::Unretained(worker_.get()),
base::RetainedRef(document_))));
@ -444,11 +435,10 @@ void PrintJob::ControlledWorkerShutdown() {
// Now make sure the thread object is cleaned up. Do this on a worker
// thread because it may block.
base::WorkerPool::PostTaskAndReply(
base::PostTaskAndReply(
FROM_HERE,
base::Bind(&PrintJobWorker::Stop, base::Unretained(worker_.get())),
base::Bind(&PrintJob::HoldUntilStopIsCalled, this),
false);
base::Bind(&PrintJob::HoldUntilStopIsCalled, this));
is_job_pending_ = false;
registrar_.RemoveAll();

12
chromium_src/chrome/browser/printing/print_job.h
View file

@ -27,7 +27,6 @@ class PdfToEmfConverter;
class PrintJobWorker;
class PrintedDocument;
class PrintedPage;
class PrintedPagesSource;
class PrinterQuery;
// Manages the print work for a specific document. Talks to the printer through
@ -45,7 +44,8 @@ class PrintJob : public PrintJobWorkerOwner,
// Grabs the ownership of the PrintJobWorker from another job, which is
// usually a PrinterQuery. Set the expected page count of the print job.
void Initialize(PrintJobWorkerOwner* job, PrintedPagesSource* source,
void Initialize(PrintJobWorkerOwner* job,
const base::string16& name,
int page_count);
// content::NotificationObserver implementation.
@ -80,10 +80,6 @@ class PrintJob : public PrintJobWorkerOwner,
// our data.
bool FlushJob(base::TimeDelta timeout);
// Disconnects the PrintedPage source (PrintedPagesSource). It is done when
// the source is being destroyed.
void DisconnectSource();
// Returns true if the print job is pending, i.e. between a StartPrinting()
// and the end of the spooling.
bool is_job_pending() const;
@ -140,10 +136,6 @@ class PrintJob : public PrintJobWorkerOwner,
content::NotificationRegistrar registrar_;
// Source that generates the PrintedPage's (i.e. a WebContents). It will be
// set back to NULL if the source is deleted before this object.
PrintedPagesSource* source_;
// All the UI is done in a worker thread because many Win32 print functions
// are blocking and enters a message loop without your consent. There is one
// worker thread per print job.

4
chromium_src/chrome/browser/printing/print_job_manager.cc
View file

@ -25,7 +25,7 @@ PrintQueriesQueue::~PrintQueriesQueue() {
void PrintQueriesQueue::QueuePrinterQuery(PrinterQuery* job) {
base::AutoLock lock(lock_);
DCHECK(job);
queued_queries_.push_back(make_scoped_refptr(job));
queued_queries_.push_back(WrapRefCounted(job));
DCHECK(job->is_valid());
}
@ -47,7 +47,7 @@ scoped_refptr<PrinterQuery> PrintQueriesQueue::PopPrinterQuery(
scoped_refptr<PrinterQuery> PrintQueriesQueue::CreatePrinterQuery(
int render_process_id,
int render_frame_id) {
return make_scoped_refptr(
return WrapRefCounted(
new PrinterQuery(render_process_id, render_frame_id));
}

14
chromium_src/chrome/browser/printing/print_job_worker.cc
View file

@ -242,7 +242,7 @@ void PrintJobWorker::GetSettings(bool ask_user_for_settings,
if (ask_user_for_settings) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
base::Bind(&HoldRefCallback, WrapRefCounted(owner_),
base::Bind(&PrintJobWorker::GetSettingsWithUI,
base::Unretained(this),
document_page_count,
@ -251,14 +251,14 @@ void PrintJobWorker::GetSettings(bool ask_user_for_settings,
} else if (!device_name.empty()) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
base::Bind(&HoldRefCallback, WrapRefCounted(owner_),
base::Bind(&PrintJobWorker::InitWithDeviceName,
base::Unretained(this),
device_name)));
} else {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
base::Bind(&HoldRefCallback, WrapRefCounted(owner_),
base::Bind(&PrintJobWorker::UseDefaultSettings,
base::Unretained(this))));
}
@ -272,7 +272,7 @@ void PrintJobWorker::SetSettings(
BrowserThread::UI,
FROM_HERE,
base::Bind(&HoldRefCallback,
make_scoped_refptr(owner_),
WrapRefCounted(owner_),
base::Bind(&PrintJobWorker::UpdatePrintSettings,
base::Unretained(this),
base::Passed(&new_settings))));
@ -299,7 +299,7 @@ void PrintJobWorker::GetSettingsDone(PrintingContext::Result result) {
// PrintJob will create the new PrintedDocument.
owner_->PostTask(FROM_HERE,
base::Bind(&PrintJobWorkerOwner::GetSettingsDone,
make_scoped_refptr(owner_),
WrapRefCounted(owner_),
printing_context_->settings(),
result));
}
@ -313,7 +313,7 @@ void PrintJobWorker::GetSettingsWithUI(
// weak_factory_ creates pointers valid only on owner_ thread.
printing_context_->AskUserForSettings(
document_page_count, has_selection, is_scripted,
base::Bind(&PostOnOwnerThread, make_scoped_refptr(owner_),
base::Bind(&PostOnOwnerThread, WrapRefCounted(owner_),
base::Bind(&PrintJobWorker::GetSettingsDone,
weak_factory_.GetWeakPtr())));
}
@ -424,7 +424,7 @@ bool PrintJobWorker::IsRunning() const {
return thread_.IsRunning();
}
bool PrintJobWorker::PostTask(const tracked_objects::Location& from_here,
bool PrintJobWorker::PostTask(const base::Location& from_here,
const base::Closure& task) {
if (task_runner_.get())
return task_runner_->PostTask(from_here, task);

3
chromium_src/chrome/browser/printing/print_job_worker.h
View file

@ -7,6 +7,7 @@
#include <memory>
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
@ -76,7 +77,7 @@ class PrintJobWorker {
bool IsRunning() const;
// Posts the given task to be run.
bool PostTask(const tracked_objects::Location& from_here,
bool PostTask(const base::Location& from_here,
const base::Closure& task);
// Signals the thread to exit in the near future.

2
chromium_src/chrome/browser/printing/print_job_worker_owner.cc
View file

@ -20,7 +20,7 @@ bool PrintJobWorkerOwner::RunsTasksInCurrentSequence() const {
return task_runner_->RunsTasksInCurrentSequence();
}
bool PrintJobWorkerOwner::PostTask(const tracked_objects::Location& from_here,
bool PrintJobWorkerOwner::PostTask(const base::Location& from_here,
const base::Closure& task) {
return task_runner_->PostTask(from_here, task);
}

7
chromium_src/chrome/browser/printing/print_job_worker_owner.h
View file

@ -7,6 +7,7 @@
#include <memory>
#include "base/location.h"
#include "base/memory/ref_counted.h"
#include "printing/printing_context.h"
@ -15,10 +16,6 @@ class MessageLoop;
class SequencedTaskRunner;
}
namespace tracked_objects {
class Location;
}
namespace printing {
class PrintJobWorker;
@ -51,7 +48,7 @@ class PrintJobWorkerOwner
bool RunsTasksInCurrentSequence() const;
// Posts the given task to be run.
bool PostTask(const tracked_objects::Location& from_here,
bool PostTask(const base::Location& from_here,
const base::Closure& task);
protected:

Some files were not shown because too many files have changed in this diff Show more