diff --git a/.circleci/config.yml b/.circleci/config.yml index 08d46c1c660..cffac9a6677 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -9,16 +9,9 @@ jobs: resource_class: xlarge steps: - checkout - - run: - name: Setup for headless testing - command: sh -e /etc/init.d/xvfb start - run: name: Check for release command: | - MESSAGE="$(git log --format=%B -n 1 HEAD)" - case ${MESSAGE} in - Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV - esac if [ -n "${RUN_RELEASE_BUILD}" ]; then echo 'release build triggered from api' echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV @@ -73,16 +66,9 @@ jobs: resource_class: xlarge steps: - checkout - - run: - name: Setup for headless testing - command: sh -e /etc/init.d/xvfb start - run: name: Check for release command: | - MESSAGE="$(git log --format=%B -n 1 HEAD)" - case ${MESSAGE} in - Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV - esac if [ -n "${RUN_RELEASE_BUILD}" ]; then echo 'release build triggered from api' echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV @@ -137,16 +123,9 @@ jobs: resource_class: xlarge steps: - checkout - - run: - name: Setup for headless testing - command: sh -e /etc/init.d/xvfb start - run: name: Check for release command: | - MESSAGE="$(git log --format=%B -n 1 HEAD)" - case ${MESSAGE} in - Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV - esac if [ -n "${RUN_RELEASE_BUILD}" ]; then echo 'release build triggered from api' echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV @@ -199,6 +178,7 @@ jobs: - image: electronbuilds/electron:0.0.3 environment: TARGET_ARCH: x64 + DISPLAY: ':99.0' resource_class: xlarge steps: - checkout @@ -208,10 +188,6 @@ jobs: - run: name: Check for release command: | - MESSAGE="$(git log --format=%B -n 1 HEAD)" - case ${MESSAGE} in - Bump* ) echo 'export ELECTRON_RELEASE=1' >> $BASH_ENV - esac if [ -n "${RUN_RELEASE_BUILD}" ]; then echo 'release build triggered from api' echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV diff --git a/README.md b/README.md index 4fb36a5a036..fe228a0cd03 100644 --- a/README.md +++ b/README.md @@ -1,21 +1,22 @@ -[![Electron Logo](https://electron.atom.io/images/electron-logo.svg)](https://electron.atom.io/) +[![Electron Logo](https://electronjs.org/images/electron-logo.svg)](https://electronjs.org) [![Travis Build Status](https://travis-ci.org/electron/electron.svg?branch=master)](https://travis-ci.org/electron/electron) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/bc56v83355fi3369/branch/master?svg=true)](https://ci.appveyor.com/project/electron-bot/electron/branch/master) [![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev) [![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/) -:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/README.md) | [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW/project/README.md) | [Spanish](https://github.com/electron/electron/tree/master/docs-translations/es/project/README.md) | [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR/project/README.md) | [German](https://github.com/electron/electron/tree/master/docs-translations/de-DE/project/README.md) +:memo: Available Translations: 🇨🇳 🇹🇼 🇧🇷 🇪🇸 🇰🇷 🇯🇵 🇷🇺 🇫🇷 🇹🇭 🇳🇱 🇹🇷 🇮🇩 🇺🇦 🇨🇿 🇮🇹. +View these docs in other languages at [electron/electron-i18n](https://github.com/electron/electron-i18n/tree/master/content/). The Electron framework lets you write cross-platform desktop applications using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.org/) and [Chromium](http://www.chromium.org) and is used by the [Atom -editor](https://github.com/atom/atom) and many other [apps](https://electron.atom.io/apps). +editor](https://github.com/atom/atom) and many other [apps](https://electronjs.org/apps). Follow [@ElectronJS](https://twitter.com/electronjs) on Twitter for important announcements. -This project adheres to the Contributor Covenant +This project adheres to the Contributor Covenant [code of conduct](https://github.com/electron/electron/tree/master/CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [electron@github.com](mailto:electron@github.com). @@ -32,29 +33,29 @@ npm install electron --save-dev --save-exact The `--save-exact` flag is recommended as Electron does not follow semantic versioning. For info on how to manage Electron versions in your apps, see -[Electron versioning](https://electron.atom.io/docs/tutorial/electron-versioning/). +[Electron versioning](https://electronjs.org/docs/tutorial/electron-versioning). For more installation options and troubleshooting tips, see -[installation](https://electron.atom.io/docs/tutorial/installation/). +[installation](https://electronjs.org/docs/tutorial/installation). -## Quick Start +## Quick start -Clone and run the +Clone and run the [electron/electron-quick-start](https://github.com/electron/electron-quick-start) repository to see a minimal Electron app in action: -``` +```sh git clone https://github.com/electron/electron-quick-start cd electron-quick-start npm install npm start ``` -## Resources for Learning Electron +## Resources for learning Electron -- [electron.atom.io/docs](http://electron.atom.io/docs) - all of Electron's documentation +- [electronjs.org/docs](https://electronjs.org/docs) - all of Electron's documentation - [electron/electron-quick-start](https://github.com/electron/electron-quick-start) - a very basic starter Electron app -- [electron.atom.io/community/#boilerplates](http://electron.atom.io/community/#boilerplates) - sample starter apps created by the community +- [electronjs.org/community#boilerplates](https://electronjs.org/community#boilerplates) - sample starter apps created by the community - [electron/simple-samples](https://github.com/electron/simple-samples) - small applications with ideas for taking them further - [electron/electron-api-demos](https://github.com/electron/electron-api-demos) - an Electron app that teaches you how to use Electron - [hokein/electron-sample-apps](https://github.com/hokein/electron-sample-apps) - small demo apps for the various Electron APIs diff --git a/atom/browser/api/atom_api_app.cc b/atom/browser/api/atom_api_app.cc index d878926580a..1534f648498 100644 --- a/atom/browser/api/atom_api_app.cc +++ b/atom/browser/api/atom_api_app.cc @@ -633,12 +633,17 @@ void App::OnLogin(LoginHandler* login_handler, const base::DictionaryValue& request_details) { v8::Locker locker(isolate()); v8::HandleScope handle_scope(isolate()); - bool prevent_default = Emit( - "login", - WebContents::CreateFrom(isolate(), login_handler->GetWebContents()), - request_details, - login_handler->auth_info(), - base::Bind(&PassLoginInformation, make_scoped_refptr(login_handler))); + bool prevent_default = false; + content::WebContents* web_contents = login_handler->GetWebContents(); + if (web_contents) { + prevent_default = + Emit("login", + WebContents::CreateFrom(isolate(), web_contents), + request_details, + login_handler->auth_info(), + base::Bind(&PassLoginInformation, + make_scoped_refptr(login_handler))); + } // Default behavior is to always cancel the auth. if (!prevent_default) diff --git a/atom/browser/api/atom_api_protocol.cc b/atom/browser/api/atom_api_protocol.cc index 4ff8c5c6bab..6ea1d8b7577 100644 --- a/atom/browser/api/atom_api_protocol.cc +++ b/atom/browser/api/atom_api_protocol.cc @@ -10,6 +10,7 @@ #include "atom/browser/net/url_request_async_asar_job.h" #include "atom/browser/net/url_request_buffer_job.h" #include "atom/browser/net/url_request_fetch_job.h" +#include "atom/browser/net/url_request_stream_job.h" #include "atom/browser/net/url_request_string_job.h" #include "atom/common/native_mate_converters/callback.h" #include "atom/common/native_mate_converters/value_converter.h" @@ -208,6 +209,8 @@ void Protocol::BuildPrototype( &Protocol::RegisterProtocol) .SetMethod("registerHttpProtocol", &Protocol::RegisterProtocol) + .SetMethod("registerStreamProtocol", + &Protocol::RegisterProtocol) .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol) .SetMethod("isProtocolHandled", &Protocol::IsProtocolHandled) .SetMethod("interceptStringProtocol", @@ -218,6 +221,8 @@ void Protocol::BuildPrototype( &Protocol::InterceptProtocol) .SetMethod("interceptHttpProtocol", &Protocol::InterceptProtocol) + .SetMethod("interceptStreamProtocol", + &Protocol::InterceptProtocol) .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol); } diff --git a/atom/browser/api/atom_api_protocol.h b/atom/browser/api/atom_api_protocol.h index dfc32be6bc5..40dc30600f9 100644 --- a/atom/browser/api/atom_api_protocol.h +++ b/atom/browser/api/atom_api_protocol.h @@ -78,6 +78,10 @@ class Protocol : public mate::TrackableObject { net::URLRequestJob* MaybeCreateJob( net::URLRequest* request, net::NetworkDelegate* network_delegate) const override { + if (!request->initiator().has_value()) { + // Don't intercept this request as it was created by `net.request`. + return nullptr; + } RequestJob* request_job = new RequestJob(request, network_delegate); request_job->SetHandlerInfo(isolate_, request_context_.get(), handler_); return request_job; diff --git a/atom/browser/api/event_subscriber.cc b/atom/browser/api/event_subscriber.cc new file mode 100644 index 00000000000..7e9bef873f0 --- /dev/null +++ b/atom/browser/api/event_subscriber.cc @@ -0,0 +1,121 @@ +// Copyright (c) 2017 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. +#include + +#include "atom/browser/api/event_subscriber.h" +#include "atom/common/native_mate_converters/callback.h" + +namespace { + +// A FunctionTemplate lifetime is bound to the v8 context, so it can be safely +// stored as a global here since there's only one for the main process. +v8::Global g_cached_template; + +struct JSHandlerData { + JSHandlerData(v8::Isolate* isolate, + mate::internal::EventSubscriberBase* subscriber) + : handle_(isolate, v8::External::New(isolate, this)), + subscriber_(subscriber) { + handle_.SetWeak(this, GC, v8::WeakCallbackType::kFinalizer); + } + + static void GC(const v8::WeakCallbackInfo& data) { + delete data.GetParameter(); + } + + v8::Global handle_; + mate::internal::EventSubscriberBase* subscriber_; +}; + +void InvokeCallback(const v8::FunctionCallbackInfo& info) { + v8::Locker locker(info.GetIsolate()); + v8::HandleScope handle_scope(info.GetIsolate()); + v8::Local context = info.GetIsolate()->GetCurrentContext(); + v8::Context::Scope context_scope(context); + mate::Arguments args(info); + v8::Local handler, event; + args.GetNext(&handler); + args.GetNext(&event); + DCHECK(handler->IsExternal()); + DCHECK(event->IsString()); + JSHandlerData* handler_data = static_cast( + v8::Local::Cast(handler)->Value()); + handler_data->subscriber_->EventEmitted(mate::V8ToString(event), &args); +} + +} // namespace + +namespace mate { + +namespace internal { + +EventSubscriberBase::EventSubscriberBase(v8::Isolate* isolate, + v8::Local emitter) + : isolate_(isolate), emitter_(isolate, emitter) { + if (g_cached_template.IsEmpty()) { + g_cached_template = v8::Global( + isolate_, v8::FunctionTemplate::New(isolate_, InvokeCallback)); + } +} + +EventSubscriberBase::~EventSubscriberBase() { + if (!isolate_) { + return; + } + RemoveAllListeners(); + emitter_.Reset(); + DCHECK_EQ(js_handlers_.size(), 0); +} + +void EventSubscriberBase::On(const std::string& event_name) { + DCHECK(js_handlers_.find(event_name) == js_handlers_.end()); + v8::Locker locker(isolate_); + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + auto fn_template = g_cached_template.Get(isolate_); + auto event = mate::StringToV8(isolate_, event_name); + auto js_handler_data = new JSHandlerData(isolate_, this); + v8::Local fn = internal::BindFunctionWith( + isolate_, isolate_->GetCurrentContext(), fn_template->GetFunction(), + js_handler_data->handle_.Get(isolate_), event); + js_handlers_.insert( + std::make_pair(event_name, v8::Global(isolate_, fn))); + internal::ValueVector converted_args = {event, fn}; + internal::CallMethodWithArgs(isolate_, emitter_.Get(isolate_), "on", + &converted_args); +} + +void EventSubscriberBase::Off(const std::string& event_name) { + v8::Locker locker(isolate_); + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + auto js_handler = js_handlers_.find(event_name); + DCHECK(js_handler != js_handlers_.end()); + RemoveListener(js_handler); +} + +void EventSubscriberBase::RemoveAllListeners() { + v8::Locker locker(isolate_); + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + while (!js_handlers_.empty()) { + RemoveListener(js_handlers_.begin()); + } +} + +std::map>::iterator +EventSubscriberBase::RemoveListener( + std::map>::iterator it) { + internal::ValueVector args = {StringToV8(isolate_, it->first), + it->second.Get(isolate_)}; + internal::CallMethodWithArgs( + isolate_, v8::Local::Cast(emitter_.Get(isolate_)), + "removeListener", &args); + it->second.Reset(); + return js_handlers_.erase(it); +} + +} // namespace internal + +} // namespace mate diff --git a/atom/browser/api/event_subscriber.h b/atom/browser/api/event_subscriber.h new file mode 100644 index 00000000000..2f4f2396be4 --- /dev/null +++ b/atom/browser/api/event_subscriber.h @@ -0,0 +1,132 @@ +// Copyright (c) 2017 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#ifndef ATOM_BROWSER_API_EVENT_SUBSCRIBER_H_ +#define ATOM_BROWSER_API_EVENT_SUBSCRIBER_H_ + +#include +#include + +#include "atom/common/api/event_emitter_caller.h" +#include "base/synchronization/lock.h" +#include "content/public/browser/browser_thread.h" +#include "native_mate/native_mate/arguments.h" + +namespace mate { + +namespace internal { + +class EventSubscriberBase { + public: + EventSubscriberBase(v8::Isolate* isolate, v8::Local emitter); + virtual ~EventSubscriberBase(); + virtual void EventEmitted(const std::string& event_name, + mate::Arguments* args) = 0; + + protected: + void On(const std::string& event_name); + void Off(const std::string& event_name); + void RemoveAllListeners(); + + private: + std::map>::iterator RemoveListener( + std::map>::iterator it); + + v8::Isolate* isolate_; + v8::Global emitter_; + std::map> js_handlers_; + + DISALLOW_COPY_AND_ASSIGN(EventSubscriberBase); +}; + +} // namespace internal + +template +class EventSubscriber : internal::EventSubscriberBase { + public: + using EventCallback = void (HandlerType::*)(mate::Arguments* args); + // Alias to unique_ptr with deleter. + using unique_ptr = std::unique_ptr, + void (*)(EventSubscriber*)>; + // EventSubscriber should only be created/deleted in the main thread since it + // communicates with the V8 engine. This smart pointer makes it simpler to + // bind the lifetime of EventSubscriber with a class whose lifetime is managed + // by a non-UI thread. + class SafePtr : public unique_ptr { + public: + SafePtr() : SafePtr(nullptr) {} + explicit SafePtr(EventSubscriber* ptr) + : unique_ptr(ptr, Deleter) {} + + private: + // Custom deleter that schedules destructor invocation to the main thread. + static void Deleter(EventSubscriber* ptr) { + DCHECK( + !::content::BrowserThread::CurrentlyOn(::content::BrowserThread::UI)); + DCHECK(ptr); + // Acquire handler lock and reset handler_ to ensure that any new events + // emitted will be ignored after this function returns + base::AutoLock auto_lock(ptr->handler_lock_); + ptr->handler_ = nullptr; + content::BrowserThread::PostTask( + content::BrowserThread::UI, FROM_HERE, + base::Bind( + [](EventSubscriber* subscriber) { + delete subscriber; + }, + ptr)); + } + }; + + EventSubscriber(HandlerType* handler, + v8::Isolate* isolate, + v8::Local emitter) + : EventSubscriberBase(isolate, emitter), handler_(handler) { + DCHECK_CURRENTLY_ON(::content::BrowserThread::UI); + } + + void On(const std::string& event, EventCallback callback) { + DCHECK_CURRENTLY_ON(::content::BrowserThread::UI); + EventSubscriberBase::On(event); + callbacks_.insert(std::make_pair(event, callback)); + } + + void Off(const std::string& event) { + DCHECK_CURRENTLY_ON(::content::BrowserThread::UI); + EventSubscriberBase::Off(event); + DCHECK(callbacks_.find(event) != callbacks_.end()); + callbacks_.erase(callbacks_.find(event)); + } + + void RemoveAllListeners() { + DCHECK_CURRENTLY_ON(::content::BrowserThread::UI); + EventSubscriberBase::RemoveAllListeners(); + callbacks_.clear(); + } + + private: + void EventEmitted(const std::string& event_name, + mate::Arguments* args) override { + DCHECK_CURRENTLY_ON(::content::BrowserThread::UI); + base::AutoLock auto_lock(handler_lock_); + if (!handler_) { + // handler_ was probably destroyed by another thread and we should not + // access it. + return; + } + auto it = callbacks_.find(event_name); + if (it != callbacks_.end()) { + auto method = it->second; + (handler_->*method)(args); + } + } + + HandlerType* handler_; + base::Lock handler_lock_; + std::map callbacks_; +}; + +} // namespace mate + +#endif // ATOM_BROWSER_API_EVENT_SUBSCRIBER_H_ diff --git a/atom/browser/atom_browser_context.cc b/atom/browser/atom_browser_context.cc index 76a23cdcda4..63fb8289529 100644 --- a/atom/browser/atom_browser_context.cc +++ b/atom/browser/atom_browser_context.cc @@ -13,7 +13,6 @@ #include "atom/browser/net/about_protocol_handler.h" #include "atom/browser/net/asar/asar_protocol_handler.h" #include "atom/browser/net/atom_cert_verifier.h" -#include "atom/browser/net/atom_ct_delegate.h" #include "atom/browser/net/atom_network_delegate.h" #include "atom/browser/net/atom_url_request_job_factory.h" #include "atom/browser/net/http_protocol_handler.h" @@ -72,7 +71,6 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition, bool in_memory, const base::DictionaryValue& options) : brightray::BrowserContext(partition, in_memory), - ct_delegate_(new AtomCTDelegate), network_delegate_(new AtomNetworkDelegate), cookie_delegate_(new AtomCookieDelegate) { // Construct user agent string. @@ -192,8 +190,9 @@ content::PermissionManager* AtomBrowserContext::GetPermissionManager() { return permission_manager_.get(); } -std::unique_ptr AtomBrowserContext::CreateCertVerifier() { - return base::WrapUnique(new AtomCertVerifier(ct_delegate_.get())); +std::unique_ptr AtomBrowserContext::CreateCertVerifier( + brightray::RequireCTDelegate* ct_delegate) { + return base::WrapUnique(new AtomCertVerifier(ct_delegate)); } std::vector AtomBrowserContext::GetCookieableSchemes() { @@ -204,11 +203,6 @@ std::vector AtomBrowserContext::GetCookieableSchemes() { return default_schemes; } -net::TransportSecurityState::RequireCTDelegate* -AtomBrowserContext::GetRequireCTDelegate() { - return ct_delegate_.get(); -} - void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) { pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory, base::FilePath()); diff --git a/atom/browser/atom_browser_context.h b/atom/browser/atom_browser_context.h index 340c8f46626..7e73fa0395b 100644 --- a/atom/browser/atom_browser_context.h +++ b/atom/browser/atom_browser_context.h @@ -15,7 +15,6 @@ namespace atom { class AtomBlobReader; -class AtomCTDelegate; class AtomDownloadManagerDelegate; class AtomNetworkDelegate; class AtomPermissionManager; @@ -40,10 +39,9 @@ class AtomBrowserContext : public brightray::BrowserContext { content::ProtocolHandlerMap* protocol_handlers) override; net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory( const base::FilePath& base_path) override; - std::unique_ptr CreateCertVerifier() override; + std::unique_ptr CreateCertVerifier( + brightray::RequireCTDelegate* ct_delegate) override; std::vector GetCookieableSchemes() override; - net::TransportSecurityState::RequireCTDelegate* GetRequireCTDelegate() - override; // content::BrowserContext: content::DownloadManagerDelegate* GetDownloadManagerDelegate() override; @@ -69,7 +67,6 @@ class AtomBrowserContext : public brightray::BrowserContext { std::unique_ptr guest_manager_; std::unique_ptr permission_manager_; std::unique_ptr blob_reader_; - std::unique_ptr ct_delegate_; std::string user_agent_; bool use_cache_; diff --git a/atom/browser/atom_resource_dispatcher_host_delegate.cc b/atom/browser/atom_resource_dispatcher_host_delegate.cc index 53d91b4be95..653d81ee463 100644 --- a/atom/browser/atom_resource_dispatcher_host_delegate.cc +++ b/atom/browser/atom_resource_dispatcher_host_delegate.cc @@ -14,6 +14,7 @@ #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" @@ -34,8 +35,7 @@ namespace atom { namespace { -void OnOpenExternal(const GURL& escaped_url, - bool allowed) { +void OnOpenExternal(const GURL& escaped_url, bool allowed) { if (allowed) platform_util::OpenExternal( #if defined(OS_WIN) @@ -66,6 +66,8 @@ void HandleExternalProtocolInUI( void OnPdfResourceIntercepted( const GURL& original_url, + int render_process_host_id, + int render_frame_id, const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter) { content::WebContents* web_contents = web_contents_getter.Run(); @@ -75,7 +77,7 @@ void OnPdfResourceIntercepted( if (!WebContentsPreferences::IsPluginsEnabled(web_contents)) { auto browser_context = web_contents->GetBrowserContext(); auto download_manager = - content::BrowserContext::GetDownloadManager(browser_context); + content::BrowserContext::GetDownloadManager(browser_context); download_manager->DownloadUrl( content::DownloadUrlParameters::CreateForWebContentsMainFrame( @@ -86,26 +88,29 @@ void OnPdfResourceIntercepted( // The URL passes the original pdf resource url, that will be requested // by the webui page. // chrome://pdf-viewer/index.html?src=https://somepage/123.pdf - content::NavigationController::LoadURLParams params( - GURL(base::StringPrintf( - "%sindex.html?%s=%s", - kPdfViewerUIOrigin, - kPdfPluginSrc, - net::EscapeUrlEncodedData(original_url.spec(), false).c_str()))); + content::NavigationController::LoadURLParams params(GURL(base::StringPrintf( + "%sindex.html?%s=%s", kPdfViewerUIOrigin, kPdfPluginSrc, + net::EscapeUrlEncodedData(original_url.spec(), false).c_str()))); + + content::RenderFrameHost* frame_host = + content::RenderFrameHost::FromID(render_process_host_id, render_frame_id); + if (!frame_host) { + return; + } + + params.frame_tree_node_id = frame_host->GetFrameTreeNodeId(); web_contents->GetController().LoadURLWithParams(params); } } // namespace -AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() { -} +AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {} bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol( const GURL& url, content::ResourceRequestInfo* info) { BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, - base::Bind(&HandleExternalProtocolInUI, - url, + base::Bind(&HandleExternalProtocolInUI, url, info->GetWebContentsGetterForRequest(), info->HasUserGesture())); return true; @@ -121,16 +126,16 @@ AtomResourceDispatcherHostDelegate::CreateLoginDelegate( std::unique_ptr AtomResourceDispatcherHostDelegate::CreateClientCertStore( content::ResourceContext* resource_context) { - #if defined(USE_NSS_CERTS) - return std::unique_ptr(new net::ClientCertStoreNSS( - net::ClientCertStoreNSS::PasswordDelegateFactory())); - #elif defined(OS_WIN) - return std::unique_ptr(new net::ClientCertStoreWin()); - #elif defined(OS_MACOSX) - return std::unique_ptr(new net::ClientCertStoreMac()); - #elif defined(USE_OPENSSL) - return std::unique_ptr(); - #endif +#if defined(USE_NSS_CERTS) + return std::unique_ptr(new net::ClientCertStoreNSS( + net::ClientCertStoreNSS::PasswordDelegateFactory())); +#elif defined(OS_WIN) + return std::unique_ptr(new net::ClientCertStoreWin()); +#elif defined(OS_MACOSX) + return std::unique_ptr(new net::ClientCertStoreMac()); +#elif defined(USE_OPENSSL) + return std::unique_ptr(); +#endif } bool AtomResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream( @@ -141,11 +146,20 @@ bool AtomResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream( std::string* payload) { const content::ResourceRequestInfo* info = content::ResourceRequestInfo::ForRequest(request); - if (mime_type == "application/pdf" && info->IsMainFrame()) { + + int render_process_host_id; + int render_frame_id; + if (!info->GetAssociatedRenderFrame(&render_process_host_id, + &render_frame_id)) { + return false; + } + + if (mime_type == "application/pdf") { *origin = GURL(kPdfViewerUIOrigin); content::BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, base::Bind(&OnPdfResourceIntercepted, request->url(), + render_process_host_id, render_frame_id, info->GetWebContentsGetterForRequest())); return true; } diff --git a/atom/browser/native_window_mac.mm b/atom/browser/native_window_mac.mm index 80554a37a6d..59301fc7a98 100644 --- a/atom/browser/native_window_mac.mm +++ b/atom/browser/native_window_mac.mm @@ -337,7 +337,7 @@ bool ScopedDisableResize::disable_resize_ = false; } - (void)windowWillEnterFullScreen:(NSNotification*)notification { - // Setting resizable to true before entering fullscreen + // Setting resizable to true before entering fullscreen is_resizable_ = shell_->IsResizable(); shell_->SetResizable(true); // Hide the native toolbar before entering fullscreen, so there is no visual @@ -962,10 +962,16 @@ NativeWindowMac::NativeWindowMac( // We will manage window's lifetime ourselves. [window_ setReleasedWhenClosed:NO]; + // Hide the title bar background + if (title_bar_style_ != NORMAL) { + if (base::mac::IsAtLeastOS10_10()) { + [window_ setTitlebarAppearsTransparent:YES]; + } + } + // Hide the title bar. if (title_bar_style_ == HIDDEN_INSET) { if (base::mac::IsAtLeastOS10_10()) { - [window_ setTitlebarAppearsTransparent:YES]; base::scoped_nsobject toolbar( [[NSToolbar alloc] initWithIdentifier:@"titlebarStylingToolbar"]); [toolbar setShowsBaselineSeparator:NO]; diff --git a/atom/browser/net/atom_cert_verifier.cc b/atom/browser/net/atom_cert_verifier.cc index 9cc4a613261..eccfe614e39 100644 --- a/atom/browser/net/atom_cert_verifier.cc +++ b/atom/browser/net/atom_cert_verifier.cc @@ -5,11 +5,11 @@ #include "atom/browser/net/atom_cert_verifier.h" #include "atom/browser/browser.h" -#include "atom/browser/net/atom_ct_delegate.h" #include "atom/common/native_mate_converters/net_converter.h" #include "base/containers/linked_list.h" #include "base/memory/ptr_util.h" #include "base/memory/weak_ptr.h" +#include "brightray/browser/net/require_ct_delegate.h" #include "content/public/browser/browser_thread.h" #include "net/base/net_errors.h" #include "net/cert/cert_verify_result.h" @@ -147,7 +147,7 @@ class CertVerifierRequest : public AtomCertVerifier::Request { base::WeakPtrFactory weak_ptr_factory_; }; -AtomCertVerifier::AtomCertVerifier(AtomCTDelegate* ct_delegate) +AtomCertVerifier::AtomCertVerifier(brightray::RequireCTDelegate* ct_delegate) : default_cert_verifier_(net::CertVerifier::CreateDefault()), ct_delegate_(ct_delegate) {} diff --git a/atom/browser/net/atom_cert_verifier.h b/atom/browser/net/atom_cert_verifier.h index 76382bf4c5d..b95cfa8f6d9 100644 --- a/atom/browser/net/atom_cert_verifier.h +++ b/atom/browser/net/atom_cert_verifier.h @@ -11,9 +11,14 @@ #include "net/cert/cert_verifier.h" +namespace brightray { + +class RequireCTDelegate; + +} // namespace brightray + namespace atom { -class AtomCTDelegate; class CertVerifierRequest; struct VerifyRequestParams { @@ -25,7 +30,7 @@ struct VerifyRequestParams { class AtomCertVerifier : public net::CertVerifier { public: - explicit AtomCertVerifier(AtomCTDelegate* ct_delegate); + explicit AtomCertVerifier(brightray::RequireCTDelegate* ct_delegate); virtual ~AtomCertVerifier(); using VerifyProc = base::Callback inflight_requests_; VerifyProc verify_proc_; std::unique_ptr default_cert_verifier_; - AtomCTDelegate* ct_delegate_; + brightray::RequireCTDelegate* ct_delegate_; DISALLOW_COPY_AND_ASSIGN(AtomCertVerifier); }; diff --git a/atom/browser/net/js_asker.h b/atom/browser/net/js_asker.h index f9859f115ad..4753afb50b1 100644 --- a/atom/browser/net/js_asker.h +++ b/atom/browser/net/js_asker.h @@ -71,6 +71,7 @@ class JsAsker : public RequestJob { void Start() override { std::unique_ptr request_details( new base::DictionaryValue); + request_start_time_ = base::TimeTicks::Now(); FillRequestDetails(request_details.get(), RequestJob::request()); content::BrowserThread::PostTask( content::BrowserThread::UI, FROM_HERE, @@ -86,6 +87,15 @@ class JsAsker : public RequestJob { int GetResponseCode() const override { return net::HTTP_OK; } + // NOTE: We have to implement this method or risk a crash in blink for + // redirects! + void GetLoadTimingInfo(net::LoadTimingInfo* load_timing_info) const override { + load_timing_info->send_start = request_start_time_; + load_timing_info->send_end = request_start_time_; + load_timing_info->request_start = request_start_time_; + load_timing_info->receive_headers_end = response_start_time_; + } + void GetResponseInfo(net::HttpResponseInfo* info) override { info->headers = new net::HttpResponseHeaders(""); } @@ -93,6 +103,7 @@ class JsAsker : public RequestJob { // Called when the JS handler has sent the response, we need to decide whether // to start, or fail the job. void OnResponse(bool success, std::unique_ptr value) { + response_start_time_ = base::TimeTicks::Now(); int error = net::ERR_NOT_IMPLEMENTED; if (success && value && !internal::IsErrorOptions(value.get(), &error)) { StartAsync(std::move(value)); @@ -105,6 +116,8 @@ class JsAsker : public RequestJob { v8::Isolate* isolate_; net::URLRequestContextGetter* request_context_getter_; JavaScriptHandler handler_; + base::TimeTicks request_start_time_; + base::TimeTicks response_start_time_; base::WeakPtrFactory weak_factory_; diff --git a/atom/browser/net/url_request_stream_job.cc b/atom/browser/net/url_request_stream_job.cc new file mode 100644 index 00000000000..99e4e74cd77 --- /dev/null +++ b/atom/browser/net/url_request_stream_job.cc @@ -0,0 +1,204 @@ +// Copyright (c) 2017 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#include +#include +#include + +#include "atom/browser/net/url_request_stream_job.h" +#include "atom/common/api/event_emitter_caller.h" +#include "atom/common/atom_constants.h" +#include "atom/common/native_mate_converters/net_converter.h" +#include "atom/common/node_includes.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/string_util.h" +#include "base/time/time.h" +#include "net/filter/gzip_source_stream.h" + +namespace atom { + +URLRequestStreamJob::URLRequestStreamJob(net::URLRequest* request, + net::NetworkDelegate* network_delegate) + : JsAsker(request, network_delegate), + ended_(false), + errored_(false), + pending_io_buf_(nullptr), + pending_io_buf_size_(0), + response_headers_(nullptr), + weak_factory_(this) {} + +void URLRequestStreamJob::BeforeStartInUI(v8::Isolate* isolate, + v8::Local value) { + if (value->IsNull() || value->IsUndefined() || !value->IsObject()) { + // Invalid opts. + ended_ = true; + errored_ = true; + return; + } + + mate::Dictionary opts(isolate, v8::Local::Cast(value)); + int status_code; + if (!opts.Get("statusCode", &status_code)) { + // assume HTTP OK if statusCode is not passed. + status_code = 200; + } + std::string status("HTTP/1.1 "); + status.append(base::IntToString(status_code)); + status.append(" "); + status.append( + net::GetHttpReasonPhrase(static_cast(status_code))); + status.append("\0\0", 2); + response_headers_ = new net::HttpResponseHeaders(status); + + if (opts.Get("headers", &value)) { + mate::Converter::FromV8(isolate, value, + response_headers_.get()); + } + + if (!opts.Get("data", &value)) { + // Assume the opts is already a stream + value = opts.GetHandle(); + } else if (value->IsNullOrUndefined()) { + // "data" was explicitly passed as null or undefined, assume the user wants + // to send an empty body. + ended_ = true; + return; + } + + mate::Dictionary data(isolate, v8::Local::Cast(value)); + if (!data.Get("on", &value) || !value->IsFunction() || + !data.Get("removeListener", &value) || !value->IsFunction()) { + // If data is passed but it is not a stream, signal an error. + ended_ = true; + errored_ = true; + return; + } + + subscriber_.reset(new mate::EventSubscriber( + this, isolate, data.GetHandle())); + subscriber_->On("data", &URLRequestStreamJob::OnData); + subscriber_->On("end", &URLRequestStreamJob::OnEnd); + subscriber_->On("error", &URLRequestStreamJob::OnError); +} + +void URLRequestStreamJob::StartAsync(std::unique_ptr options) { + NotifyHeadersComplete(); +} + +void URLRequestStreamJob::OnData(mate::Arguments* args) { + v8::Local node_data; + args->GetNext(&node_data); + if (node_data->IsUint8Array()) { + const char* data = node::Buffer::Data(node_data); + size_t data_size = node::Buffer::Length(node_data); + std::copy(data, data + data_size, std::back_inserter(buffer_)); + } else { + NOTREACHED(); + } + if (pending_io_buf_) { + CopyMoreData(pending_io_buf_, pending_io_buf_size_); + } +} + +void URLRequestStreamJob::OnEnd(mate::Arguments* args) { + ended_ = true; + if (pending_io_buf_) { + CopyMoreData(pending_io_buf_, pending_io_buf_size_); + } +} + +void URLRequestStreamJob::OnError(mate::Arguments* args) { + errored_ = true; + if (pending_io_buf_) { + CopyMoreData(pending_io_buf_, pending_io_buf_size_); + } +} + +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)); + return net::ERR_IO_PENDING; +} + +void URLRequestStreamJob::DoneReading() { + subscriber_.reset(); + buffer_.clear(); + ended_ = true; +} + +void URLRequestStreamJob::DoneReadingRedirectResponse() { + DoneReading(); +} + +void URLRequestStreamJob::CopyMoreDataDone(scoped_refptr io_buf, + int status) { + if (status <= 0) { + subscriber_.reset(); + } + ReadRawDataComplete(status); + io_buf = nullptr; +} + +void URLRequestStreamJob::CopyMoreData(scoped_refptr io_buf, + int io_buf_size) { + // reset any instance references to io_buf + pending_io_buf_ = nullptr; + pending_io_buf_size_ = 0; + + int read_count = 0; + if (buffer_.size()) { + size_t count = std::min((size_t)io_buf_size, buffer_.size()); + std::copy(buffer_.begin(), buffer_.begin() + count, io_buf->data()); + buffer_.erase(buffer_.begin(), buffer_.begin() + count); + read_count = count; + } else if (!ended_ && !errored_) { + // No data available yet, save references to the IOBuffer, which will be + // passed back to this function when OnData/OnEnd/OnError are called + pending_io_buf_ = io_buf; + pending_io_buf_size_ = io_buf_size; + } + + if (!pending_io_buf_) { + // Only call CopyMoreDataDone if we have read something. + int status = (errored_ && !read_count) ? net::ERR_FAILED : read_count; + content::BrowserThread::PostTask( + content::BrowserThread::IO, FROM_HERE, + base::Bind(&URLRequestStreamJob::CopyMoreDataDone, + weak_factory_.GetWeakPtr(), io_buf, status)); + } +} + +std::unique_ptr URLRequestStreamJob::SetUpSourceStream() { + std::unique_ptr source = + net::URLRequestJob::SetUpSourceStream(); + size_t i = 0; + std::string type; + while (response_headers_->EnumerateHeader(&i, "Content-Encoding", &type)) { + if (base::LowerCaseEqualsASCII(type, "gzip") || + base::LowerCaseEqualsASCII(type, "x-gzip")) { + return net::GzipSourceStream::Create(std::move(source), + net::SourceStream::TYPE_GZIP); + } else if (base::LowerCaseEqualsASCII(type, "deflate")) { + return net::GzipSourceStream::Create(std::move(source), + net::SourceStream::TYPE_DEFLATE); + } + } + return source; +} + +bool URLRequestStreamJob::GetMimeType(std::string* mime_type) const { + return response_headers_->GetMimeType(mime_type); +} + +int URLRequestStreamJob::GetResponseCode() const { + return response_headers_->response_code(); +} + +void URLRequestStreamJob::GetResponseInfo(net::HttpResponseInfo* info) { + info->headers = response_headers_; +} + +} // namespace atom diff --git a/atom/browser/net/url_request_stream_job.h b/atom/browser/net/url_request_stream_job.h new file mode 100644 index 00000000000..372cad7e2d5 --- /dev/null +++ b/atom/browser/net/url_request_stream_job.h @@ -0,0 +1,66 @@ +// Copyright (c) 2017 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#ifndef ATOM_BROWSER_NET_URL_REQUEST_STREAM_JOB_H_ +#define ATOM_BROWSER_NET_URL_REQUEST_STREAM_JOB_H_ + +#include +#include + +#include "atom/browser/api/event_subscriber.h" +#include "atom/browser/net/js_asker.h" +#include "base/memory/ref_counted_memory.h" +#include "native_mate/persistent_dictionary.h" +#include "net/base/io_buffer.h" +#include "net/http/http_status_code.h" +#include "net/url_request/url_request_context_getter.h" +#include "v8/include/v8.h" + +namespace atom { + +class URLRequestStreamJob : public JsAsker { + public: + URLRequestStreamJob(net::URLRequest* request, + net::NetworkDelegate* network_delegate); + + void OnData(mate::Arguments* args); + void OnEnd(mate::Arguments* args); + void OnError(mate::Arguments* args); + + // URLRequestJob + void GetResponseInfo(net::HttpResponseInfo* info) override; + + protected: + // URLRequestJob + int ReadRawData(net::IOBuffer* buf, int buf_size) override; + void DoneReading() override; + void DoneReadingRedirectResponse() override; + std::unique_ptr SetUpSourceStream() override; + bool GetMimeType(std::string* mime_type) const override; + int GetResponseCode() const override; + + private: + // JSAsker + void BeforeStartInUI(v8::Isolate*, v8::Local) override; + void StartAsync(std::unique_ptr options) override; + void OnResponse(bool success, std::unique_ptr value); + + // Callback after data is asynchronously read from the file into |buf|. + void CopyMoreData(scoped_refptr io_buf, int io_buf_size); + void CopyMoreDataDone(scoped_refptr io_buf, int read_count); + + std::deque buffer_; + bool ended_; + bool errored_; + scoped_refptr pending_io_buf_; + int pending_io_buf_size_; + scoped_refptr response_headers_; + mate::EventSubscriber::SafePtr subscriber_; + base::WeakPtrFactory weak_factory_; + + DISALLOW_COPY_AND_ASSIGN(URLRequestStreamJob); +}; +} // namespace atom + +#endif // ATOM_BROWSER_NET_URL_REQUEST_STREAM_JOB_H_ diff --git a/atom/browser/ui/webui/pdf_viewer_handler.cc b/atom/browser/ui/webui/pdf_viewer_handler.cc index aee7ff05493..cc51d2d92df 100644 --- a/atom/browser/ui/webui/pdf_viewer_handler.cc +++ b/atom/browser/ui/webui/pdf_viewer_handler.cc @@ -58,7 +58,9 @@ void PopulateStreamInfo(base::DictionaryValue* stream_info, PdfViewerHandler::PdfViewerHandler(const std::string& src) : stream_(nullptr), original_url_(src) {} -PdfViewerHandler::~PdfViewerHandler() {} +PdfViewerHandler::~PdfViewerHandler() { + RemoveObserver(); +} void PdfViewerHandler::SetPdfResourceStream(content::StreamInfo* stream) { stream_ = stream; @@ -90,15 +92,11 @@ void PdfViewerHandler::RegisterMessages() { } void PdfViewerHandler::OnJavascriptAllowed() { - auto zoom_controller = WebContentsZoomController::FromWebContents( - web_ui()->GetWebContents()); - zoom_controller->AddObserver(this); + AddObserver(); } void PdfViewerHandler::OnJavascriptDisallowed() { - auto zoom_controller = WebContentsZoomController::FromWebContents( - web_ui()->GetWebContents()); - zoom_controller->RemoveObserver(this); + RemoveObserver(); } void PdfViewerHandler::Initialize(const base::ListValue* args) { @@ -214,4 +212,16 @@ void PdfViewerHandler::OnZoomLevelChanged(content::WebContents* web_contents, } } +void PdfViewerHandler::AddObserver() { + auto zoom_controller = + WebContentsZoomController::FromWebContents(web_ui()->GetWebContents()); + zoom_controller->AddObserver(this); +} + +void PdfViewerHandler::RemoveObserver() { + auto zoom_controller = + WebContentsZoomController::FromWebContents(web_ui()->GetWebContents()); + zoom_controller->RemoveObserver(this); +} + } // namespace atom diff --git a/atom/browser/ui/webui/pdf_viewer_handler.h b/atom/browser/ui/webui/pdf_viewer_handler.h index e6ae315e876..2da19e684cd 100644 --- a/atom/browser/ui/webui/pdf_viewer_handler.h +++ b/atom/browser/ui/webui/pdf_viewer_handler.h @@ -45,7 +45,8 @@ class PdfViewerHandler : public content::WebUIMessageHandler, void Reload(const base::ListValue* args); void OnZoomLevelChanged(content::WebContents* web_contents, double level, bool is_temporary); - + void AddObserver(); + void RemoveObserver(); std::unique_ptr initialize_callback_id_; content::StreamInfo* stream_; std::string original_url_; diff --git a/atom/common/api/event_emitter_caller.cc b/atom/common/api/event_emitter_caller.cc index 50d586680d5..ff920c67973 100644 --- a/atom/common/api/event_emitter_caller.cc +++ b/atom/common/api/event_emitter_caller.cc @@ -20,8 +20,18 @@ v8::Local CallMethodWithArgs(v8::Isolate* isolate, v8::MicrotasksScope::kRunMicrotasks); // Use node::MakeCallback to call the callback, and it will also run pending // tasks in Node.js. - return node::MakeCallback(isolate, obj, method, args->size(), &args->front(), - {0, 0}).ToLocalChecked(); + v8::MaybeLocal ret = node::MakeCallback(isolate, obj, method, + args->size(), + &args->front(), {0, 0}); + // If the JS function throws an exception (doesn't return a value) the result + // of MakeCallback will be empty and therefore ToLocal will be false, in this + // case we need to return "false" as that indicates that the event emitter did + // not handle the event + v8::Local localRet; + if (ret.ToLocal(&localRet)) { + return localRet; + } + return v8::Boolean::New(isolate, false); } } // namespace internal diff --git a/atom/common/atom_version.h b/atom/common/atom_version.h index c80b709304a..a279283cf09 100644 --- a/atom/common/atom_version.h +++ b/atom/common/atom_version.h @@ -8,11 +8,10 @@ #define ATOM_MAJOR_VERSION 1 #define ATOM_MINOR_VERSION 8 #define ATOM_PATCH_VERSION 2 +#define ATOM_PRE_RELEASE_VERSION -beta.2 -#define ATOM_VERSION_IS_RELEASE 1 - -#ifndef ATOM_TAG -# define ATOM_TAG "" +#ifndef ATOM_PRE_RELEASE_VERSION +# define ATOM_PRE_RELEASE_VERSION "" #endif #ifndef ATOM_STRINGIFY @@ -20,17 +19,10 @@ #define ATOM_STRINGIFY_HELPER(n) #n #endif -#if ATOM_VERSION_IS_RELEASE # define ATOM_VERSION_STRING ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \ ATOM_STRINGIFY(ATOM_MINOR_VERSION) "." \ ATOM_STRINGIFY(ATOM_PATCH_VERSION) \ - ATOM_TAG -#else -# define ATOM_VERSION_STRING ATOM_STRINGIFY(ATOM_MAJOR_VERSION) "." \ - ATOM_STRINGIFY(ATOM_MINOR_VERSION) "." \ - ATOM_STRINGIFY(ATOM_PATCH_VERSION) \ - ATOM_TAG "-pre" -#endif + ATOM_STRINGIFY(ATOM_PRE_RELEASE_VERSION) #define ATOM_VERSION "v" ATOM_VERSION_STRING diff --git a/atom/common/native_mate_converters/callback.cc b/atom/common/native_mate_converters/callback.cc index a6a500be73a..0132ae78582 100644 --- a/atom/common/native_mate_converters/callback.cc +++ b/atom/common/native_mate_converters/callback.cc @@ -38,22 +38,6 @@ void CallTranslater(v8::Local external, delete holder; } -// func.bind(func, arg1). -// NB(zcbenz): Using C++11 version crashes VS. -v8::Local BindFunctionWith(v8::Isolate* isolate, - v8::Local context, - v8::Local func, - v8::Local arg1, - v8::Local arg2) { - v8::MaybeLocal bind = func->Get(mate::StringToV8(isolate, "bind")); - CHECK(!bind.IsEmpty()); - v8::Local bind_func = - v8::Local::Cast(bind.ToLocalChecked()); - v8::Local converted[] = { func, arg1, arg2 }; - return bind_func->Call( - context, func, arraysize(converted), converted).ToLocalChecked(); -} - } // namespace // Destroy the class on UI thread when possible. @@ -130,6 +114,22 @@ v8::Local CreateFunctionFromTranslater( v8::Object::New(isolate)); } +// func.bind(func, arg1). +// NB(zcbenz): Using C++11 version crashes VS. +v8::Local BindFunctionWith(v8::Isolate* isolate, + v8::Local context, + v8::Local func, + v8::Local arg1, + v8::Local arg2) { + v8::MaybeLocal bind = func->Get(mate::StringToV8(isolate, "bind")); + CHECK(!bind.IsEmpty()); + v8::Local bind_func = + v8::Local::Cast(bind.ToLocalChecked()); + v8::Local converted[] = {func, arg1, arg2}; + return bind_func->Call(context, func, arraysize(converted), converted) + .ToLocalChecked(); +} + } // namespace internal } // namespace mate diff --git a/atom/common/native_mate_converters/callback.h b/atom/common/native_mate_converters/callback.h index 34c6e5d62de..fc93e83d312 100644 --- a/atom/common/native_mate_converters/callback.h +++ b/atom/common/native_mate_converters/callback.h @@ -111,6 +111,11 @@ struct V8FunctionInvoker { using Translater = base::Callback; v8::Local CreateFunctionFromTranslater( v8::Isolate* isolate, const Translater& translater); +v8::Local BindFunctionWith(v8::Isolate* isolate, + v8::Local context, + v8::Local func, + v8::Local arg1, + v8::Local arg2); // Calls callback with Arguments. template diff --git a/atom/common/native_mate_converters/net_converter.cc b/atom/common/native_mate_converters/net_converter.cc index 3dbee4fadb8..05c20ea6be2 100644 --- a/atom/common/native_mate_converters/net_converter.cc +++ b/atom/common/native_mate_converters/net_converter.cc @@ -165,6 +165,35 @@ v8::Local Converter::ToV8( return ConvertToV8(isolate, response_headers); } +bool Converter::FromV8( + v8::Isolate* isolate, + v8::Local val, + net::HttpResponseHeaders* out) { + if (!val->IsObject()) { + return false; + } + auto context = isolate->GetCurrentContext(); + auto headers = v8::Local::Cast(val); + auto keys = headers->GetOwnPropertyNames(); + for (uint32_t i = 0; i < keys->Length(); i++) { + v8::Local key, value; + if (!keys->Get(i)->ToString(context).ToLocal(&key)) { + return false; + } + if (!headers->Get(key)->ToString(context).ToLocal(&value)) { + return false; + } + v8::String::Utf8Value key_utf8(key); + v8::String::Utf8Value value_utf8(value); + std::string k(*key_utf8, key_utf8.length()); + std::string v(*value_utf8, value_utf8.length()); + std::ostringstream tmp; + tmp << k << ": " << v; + out->AddHeader(tmp.str()); + } + return true; +} + } // namespace mate namespace atom { @@ -180,6 +209,13 @@ void FillRequestDetails(base::DictionaryValue* details, GetUploadData(list.get(), request); if (!list->empty()) details->Set("uploadData", std::move(list)); + std::unique_ptr headers_value( + new base::DictionaryValue); + for (net::HttpRequestHeaders::Iterator it(request->extra_request_headers()); + it.GetNext();) { + headers_value->SetString(it.name(), it.value()); + } + details->Set("headers", std::move(headers_value)); } void GetUploadData(base::ListValue* upload_data_list, diff --git a/atom/common/native_mate_converters/net_converter.h b/atom/common/native_mate_converters/net_converter.h index 9e3128fdb54..b73ae6ea980 100644 --- a/atom/common/native_mate_converters/net_converter.h +++ b/atom/common/native_mate_converters/net_converter.h @@ -49,6 +49,9 @@ template <> struct Converter { static v8::Local ToV8(v8::Isolate* isolate, net::HttpResponseHeaders* headers); + static bool FromV8(v8::Isolate* isolate, + v8::Local val, + net::HttpResponseHeaders* out); }; } // namespace mate diff --git a/atom/browser/net/atom_ct_delegate.cc b/brightray/browser/net/require_ct_delegate.cc similarity index 58% rename from atom/browser/net/atom_ct_delegate.cc rename to brightray/browser/net/require_ct_delegate.cc index 66d6c93adb3..b3c57650bf0 100644 --- a/atom/browser/net/atom_ct_delegate.cc +++ b/brightray/browser/net/require_ct_delegate.cc @@ -1,28 +1,28 @@ -// Copyright (c) 2016 GitHub, Inc. +// Copyright (c) 2017 GitHub, Inc. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. -#include "atom/browser/net/atom_ct_delegate.h" +#include "brightray/browser/net/require_ct_delegate.h" #include "content/public/browser/browser_thread.h" -namespace atom { +namespace brightray { -AtomCTDelegate::AtomCTDelegate() {} +RequireCTDelegate::RequireCTDelegate() {} -AtomCTDelegate::~AtomCTDelegate() {} +RequireCTDelegate::~RequireCTDelegate() {} -void AtomCTDelegate::AddCTExcludedHost(const std::string& host) { +void RequireCTDelegate::AddCTExcludedHost(const std::string& host) { DCHECK_CURRENTLY_ON(content::BrowserThread::IO); ct_excluded_hosts_.insert(host); } -void AtomCTDelegate::ClearCTExcludedHostsList() { +void RequireCTDelegate::ClearCTExcludedHostsList() { DCHECK_CURRENTLY_ON(content::BrowserThread::IO); ct_excluded_hosts_.clear(); } -AtomCTDelegate::CTRequirementLevel AtomCTDelegate::IsCTRequiredForHost( +RequireCTDelegate::CTRequirementLevel RequireCTDelegate::IsCTRequiredForHost( const std::string& host) { DCHECK_CURRENTLY_ON(content::BrowserThread::IO); if (!ct_excluded_hosts_.empty() && @@ -31,4 +31,4 @@ AtomCTDelegate::CTRequirementLevel AtomCTDelegate::IsCTRequiredForHost( return CTRequirementLevel::DEFAULT; } -} // namespace atom +} // namespace brightray diff --git a/atom/browser/net/atom_ct_delegate.h b/brightray/browser/net/require_ct_delegate.h similarity index 52% rename from atom/browser/net/atom_ct_delegate.h rename to brightray/browser/net/require_ct_delegate.h index 680071eaa06..6fcb1c63f10 100644 --- a/atom/browser/net/atom_ct_delegate.h +++ b/brightray/browser/net/require_ct_delegate.h @@ -1,21 +1,22 @@ -// Copyright (c) 2016 GitHub, Inc. +// Copyright (c) 2017 GitHub, Inc. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. -#ifndef ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_ -#define ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_ +#ifndef BRIGHTRAY_BROWSER_NET_REQUIRE_CT_DELEGATE_H_ +#define BRIGHTRAY_BROWSER_NET_REQUIRE_CT_DELEGATE_H_ #include #include #include "net/http/transport_security_state.h" -namespace atom { +namespace brightray { -class AtomCTDelegate : public net::TransportSecurityState::RequireCTDelegate { +class RequireCTDelegate + : public net::TransportSecurityState::RequireCTDelegate { public: - AtomCTDelegate(); - ~AtomCTDelegate() override; + RequireCTDelegate(); + ~RequireCTDelegate() override; void AddCTExcludedHost(const std::string& host); void ClearCTExcludedHostsList(); @@ -25,9 +26,9 @@ class AtomCTDelegate : public net::TransportSecurityState::RequireCTDelegate { private: std::set ct_excluded_hosts_; - DISALLOW_COPY_AND_ASSIGN(AtomCTDelegate); + DISALLOW_COPY_AND_ASSIGN(RequireCTDelegate); }; -} // namespace atom +} // namespace brightray -#endif // ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_ +#endif // BRIGHTRAY_BROWSER_NET_REQUIRE_CT_DELEGATE_H_ diff --git a/brightray/browser/url_request_context_getter.cc b/brightray/browser/url_request_context_getter.cc index 3db62729a67..f9efcb7a547 100644 --- a/brightray/browser/url_request_context_getter.cc +++ b/brightray/browser/url_request_context_getter.cc @@ -14,6 +14,7 @@ #include "base/threading/worker_pool.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" #include "brightray/common/switches.h" @@ -107,7 +108,8 @@ URLRequestContextGetter::Delegate::CreateHttpCacheBackendFactory( } std::unique_ptr -URLRequestContextGetter::Delegate::CreateCertVerifier() { +URLRequestContextGetter::Delegate::CreateCertVerifier( + RequireCTDelegate* ct_delegate) { return net::CertVerifier::CreateDefault(); } @@ -170,6 +172,7 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); if (!url_request_context_.get()) { + ct_delegate_.reset(new RequireCTDelegate); auto& command_line = *base::CommandLine::ForCurrentProcess(); url_request_context_.reset(new net::URLRequestContext); @@ -280,10 +283,10 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() { std::unique_ptr transport_security_state = base::WrapUnique(new net::TransportSecurityState); - transport_security_state->SetRequireCTDelegate( - delegate_->GetRequireCTDelegate()); + transport_security_state->SetRequireCTDelegate(ct_delegate_.get()); storage_->set_transport_security_state(std::move(transport_security_state)); - storage_->set_cert_verifier(delegate_->CreateCertVerifier()); + storage_->set_cert_verifier( + delegate_->CreateCertVerifier(ct_delegate_.get())); storage_->set_ssl_config_service(delegate_->CreateSSLConfigService()); storage_->set_http_auth_handler_factory(std::move(auth_handler_factory)); std::unique_ptr server_properties( diff --git a/brightray/browser/url_request_context_getter.h b/brightray/browser/url_request_context_getter.h index a7ced2ea7be..dbd05ddfc0d 100644 --- a/brightray/browser/url_request_context_getter.h +++ b/brightray/browser/url_request_context_getter.h @@ -33,6 +33,7 @@ class URLRequestJobFactory; namespace brightray { +class RequireCTDelegate; class DevToolsNetworkControllerHandle; class MediaDeviceIDSalt; class NetLog; @@ -53,13 +54,10 @@ class URLRequestContextGetter : public net::URLRequestContextGetter { CreateURLRequestJobFactory(content::ProtocolHandlerMap* protocol_handlers); virtual net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory( const base::FilePath& base_path); - virtual std::unique_ptr CreateCertVerifier(); + virtual std::unique_ptr CreateCertVerifier( + RequireCTDelegate* ct_delegate); virtual net::SSLConfigService* CreateSSLConfigService(); virtual std::vector GetCookieableSchemes(); - virtual net::TransportSecurityState::RequireCTDelegate* - GetRequireCTDelegate() { - return nullptr; - } virtual MediaDeviceIDSalt* GetMediaDeviceIDSalt() { return nullptr; } }; @@ -98,6 +96,7 @@ class URLRequestContextGetter : public net::URLRequestContextGetter { std::string user_agent_; + std::unique_ptr ct_delegate_; std::unique_ptr proxy_config_service_; std::unique_ptr network_delegate_; std::unique_ptr storage_; diff --git a/brightray/filenames.gypi b/brightray/filenames.gypi index f8f89ea94b6..e1b10600b09 100644 --- a/brightray/filenames.gypi +++ b/brightray/filenames.gypi @@ -61,6 +61,8 @@ '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', 'browser/net_log.h', 'browser/network_delegate.cc', diff --git a/default_app/index.html b/default_app/index.html index 3768f41482b..c8564cb57a1 100644 --- a/default_app/index.html +++ b/default_app/index.html @@ -204,7 +204,7 @@