From b2a8678c47374dd8413920016a622d41653f8435 Mon Sep 17 00:00:00 2001 From: Cheng Zhao Date: Thu, 25 Jun 2015 14:28:13 +0800 Subject: [PATCH] Move BrowserPluginGuestDelegate to a separate class --- atom/browser/api/atom_api_web_contents.cc | 158 ++----------------- atom/browser/api/atom_api_web_contents.h | 82 +--------- atom/browser/api/event_emitter.h | 6 +- atom/browser/web_view_guest_delegate.cc | 175 ++++++++++++++++++++++ atom/browser/web_view_guest_delegate.h | 122 +++++++++++++++ filenames.gypi | 2 + 6 files changed, 322 insertions(+), 223 deletions(-) create mode 100644 atom/browser/web_view_guest_delegate.cc create mode 100644 atom/browser/web_view_guest_delegate.h diff --git a/atom/browser/api/atom_api_web_contents.cc b/atom/browser/api/atom_api_web_contents.cc index ef49218e1819..4aa5c1c54e2c 100644 --- a/atom/browser/api/atom_api_web_contents.cc +++ b/atom/browser/api/atom_api_web_contents.cc @@ -11,6 +11,7 @@ #include "atom/browser/atom_browser_context.h" #include "atom/browser/atom_browser_main_parts.h" #include "atom/browser/native_window.h" +#include "atom/browser/web_view_guest_delegate.h" #include "atom/common/api/api_messages.h" #include "atom/common/event_emitter_caller.h" #include "atom/common/native_mate_converters/gfx_converter.h" @@ -24,14 +25,12 @@ #include "chrome/browser/printing/print_view_manager_basic.h" #include "chrome/browser/printing/print_preview_message_handler.h" #include "content/public/browser/favicon_status.h" -#include "content/public/browser/guest_host.h" #include "content/public/browser/navigation_details.h" #include "content/public/browser/navigation_entry.h" #include "content/public/browser/plugin_service.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/render_widget_host_view.h" #include "content/public/browser/resource_request_details.h" #include "content/public/browser/service_worker_context.h" #include "content/public/browser/storage_partition.h" @@ -57,10 +56,10 @@ struct PrintSettings { namespace mate { template<> -struct Converter { +struct Converter { static bool FromV8(v8::Isolate* isolate, v8::Local val, - atom::api::SetSizeParams* out) { + atom::SetSizeParams* out) { mate::Dictionary params; if (!ConvertFromV8(isolate, val, ¶ms)) return false; @@ -116,9 +115,6 @@ namespace api { namespace { -const int kDefaultWidth = 300; -const int kDefaultHeight = 300; - v8::Persistent template_; // The wrapWebContents funtion which is implemented in JavaScript @@ -144,20 +140,12 @@ content::ServiceWorkerContext* GetServiceWorkerContext( WebContents::WebContents(content::WebContents* web_contents) : content::WebContentsObserver(web_contents), - guest_opaque_(true), - guest_host_(nullptr), - auto_size_enabled_(false), - is_full_page_plugin_(false), type_(REMOTE), inspectable_web_contents_(nullptr) { AttachAsUserData(web_contents); } -WebContents::WebContents(const mate::Dictionary& options) - : guest_opaque_(true), - guest_host_(nullptr), - auto_size_enabled_(false), - is_full_page_plugin_(false) { +WebContents::WebContents(const mate::Dictionary& options) { bool is_guest = false; options.Get("isGuest", &is_guest); @@ -169,7 +157,8 @@ WebContents::WebContents(const mate::Dictionary& options) content::SiteInstance* site_instance = content::SiteInstance::CreateForURL( browser_context, GURL("chrome-guest://fake-host")); content::WebContents::CreateParams params(browser_context, site_instance); - params.guest_delegate = this; + guest_delegate_.reset(new WebViewGuestDelegate); + params.guest_delegate = guest_delegate_.get(); web_contents = content::WebContents::Create(params); } else { content::WebContents::CreateParams params(browser_context); @@ -182,6 +171,8 @@ WebContents::WebContents(const mate::Dictionary& options) inspectable_web_contents_ = managed_web_contents(); if (is_guest) { + guest_delegate_->Initialize(this); + NativeWindow* owner_window = nullptr; WebContents* embedder = nullptr; if (options.Get("embedder", &embedder) && embedder) { @@ -279,9 +270,9 @@ void WebContents::HandleKeyboardEvent( const content::NativeWebKeyboardEvent& event) { if (type_ == BROWSER_WINDOW) { owner_window()->HandleKeyboardEvent(source, event); - } else if (type_ == WEB_VIEW && !attached()) { + } else if (type_ == WEB_VIEW && guest_delegate_) { // Send the unhandled keyboard events back to the embedder. - embedder_web_contents_->GetDelegate()->HandleKeyboardEvent(source, event); + guest_delegate_->HandleKeyboardEvent(source, event); } } @@ -467,21 +458,6 @@ bool WebContents::OnMessageReceived(const IPC::Message& message) { return handled; } -void WebContents::RenderViewReady() { - if (type_ != WEB_VIEW) - return; - - // We don't want to accidentally set the opacity of an interstitial page. - // WebContents::GetRenderWidgetHostView will return the RWHV of an - // interstitial page if one is showing at this time. We only want opacity - // to apply to web pages. - auto render_view_host_view = web_contents()->GetRenderViewHost()->GetView(); - if (guest_opaque_) - render_view_host_view->SetBackgroundColorToDefault(); - else - render_view_host_view->SetBackgroundColor(SK_ColorTRANSPARENT); -} - void WebContents::WebContentsDestroyed() { // The RenderViewDeleted was not called when the WebContents is destroyed. RenderViewDeleted(web_contents()->GetRenderViewHost()); @@ -495,40 +471,12 @@ void WebContents::NavigationEntryCommitted( details.is_in_page, details.did_replace_entry); } -void WebContents::DidAttach(int guest_proxy_routing_id) { - Emit("did-attach"); -} - -content::WebContents* WebContents::GetOwnerWebContents() const { - return embedder_web_contents_; -} - -void WebContents::GuestSizeChanged(const gfx::Size& new_size) { - if (!auto_size_enabled_) - return; - GuestSizeChangedDueToAutoSize(guest_size_, new_size); - guest_size_ = new_size; -} - -void WebContents::SetGuestHost(content::GuestHost* guest_host) { - guest_host_ = guest_host; -} - -void WebContents::WillAttach(content::WebContents* embedder_web_contents, - int element_instance_id, - bool is_full_page_plugin) { - embedder_web_contents_ = embedder_web_contents; - is_full_page_plugin_ = is_full_page_plugin; -} - void WebContents::Destroy() { if (type_ == WEB_VIEW && managed_web_contents()) { // When force destroying the "destroyed" event is not emitted. WebContentsDestroyed(); - // Give the content module an opportunity to perform some cleanup. - guest_host_->WillDestroy(); - guest_host_ = nullptr; + guest_delegate_->Destroy(); Observe(nullptr); DestroyWebContents(); @@ -781,72 +729,13 @@ bool WebContents::SendIPCMessage(const base::string16& channel, } void WebContents::SetSize(const SetSizeParams& params) { - bool enable_auto_size = - params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_; - gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_; - gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_; - - if (params.normal_size) - normal_size_ = *params.normal_size; - - min_auto_size_ = min_size; - min_auto_size_.SetToMin(max_size); - max_auto_size_ = max_size; - max_auto_size_.SetToMax(min_size); - - enable_auto_size &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty(); - - content::RenderViewHost* rvh = web_contents()->GetRenderViewHost(); - if (enable_auto_size) { - // Autosize is being enabled. - rvh->EnableAutoResize(min_auto_size_, max_auto_size_); - normal_size_.SetSize(0, 0); - } else { - // Autosize is being disabled. - // Use default width/height if missing from partially defined normal size. - if (normal_size_.width() && !normal_size_.height()) - normal_size_.set_height(GetDefaultSize().height()); - if (!normal_size_.width() && normal_size_.height()) - normal_size_.set_width(GetDefaultSize().width()); - - gfx::Size new_size; - if (!normal_size_.IsEmpty()) { - new_size = normal_size_; - } else if (!guest_size_.IsEmpty()) { - new_size = guest_size_; - } else { - new_size = GetDefaultSize(); - } - - if (auto_size_enabled_) { - // Autosize was previously enabled. - rvh->DisableAutoResize(new_size); - GuestSizeChangedDueToAutoSize(guest_size_, new_size); - } else { - // Autosize was already disabled. - guest_host_->SizeContents(new_size); - } - - guest_size_ = new_size; - } - - auto_size_enabled_ = enable_auto_size; + if (guest_delegate_) + guest_delegate_->SetSize(params); } void WebContents::SetAllowTransparency(bool allow) { - if (guest_opaque_ != allow) - return; - - auto render_view_host = web_contents()->GetRenderViewHost(); - guest_opaque_ = !allow; - if (!render_view_host->GetView()) - return; - - if (guest_opaque_) { - render_view_host->GetView()->SetBackgroundColorToDefault(); - } else { - render_view_host->GetView()->SetBackgroundColor(SK_ColorTRANSPARENT); - } + if (guest_delegate_) + guest_delegate_->SetAllowTransparency(allow); } bool WebContents::IsGuest() const { @@ -922,23 +811,6 @@ void WebContents::OnRendererMessageSync(const base::string16& channel, EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args); } -void WebContents::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size, - const gfx::Size& new_size) { - Emit("size-changed", - old_size.width(), old_size.height(), - new_size.width(), new_size.height()); -} - -gfx::Size WebContents::GetDefaultSize() const { - if (is_full_page_plugin_) { - // Full page plugins default to the size of the owner's viewport. - return embedder_web_contents_->GetRenderWidgetHostView() - ->GetVisibleViewportSize(); - } else { - return gfx::Size(kDefaultWidth, kDefaultHeight); - } -} - // static mate::Handle WebContents::CreateFrom( v8::Isolate* isolate, content::WebContents* web_contents) { diff --git a/atom/browser/api/atom_api_web_contents.h b/atom/browser/api/atom_api_web_contents.h index 55f087742069..677daf41854d 100644 --- a/atom/browser/api/atom_api_web_contents.h +++ b/atom/browser/api/atom_api_web_contents.h @@ -10,7 +10,6 @@ #include "atom/browser/api/trackable_object.h" #include "atom/browser/common_web_contents_delegate.h" -#include "content/public/browser/browser_plugin_guest_delegate.h" #include "content/public/common/favicon_url.h" #include "content/public/browser/web_contents_observer.h" #include "content/public/browser/gpu_data_manager_observer.h" @@ -28,26 +27,12 @@ class Dictionary; namespace atom { +struct SetSizeParams; +class WebViewGuestDelegate; + namespace api { -// A struct of parameters for SetSize(). The parameters are all declared as -// scoped pointers since they are all optional. Null pointers indicate that the -// parameter has not been provided, and the last used value should be used. Note -// that when |enable_auto_size| is true, providing |normal_size| is not -// meaningful. This is because the normal size of the guestview is overridden -// whenever autosizing occurs. -struct SetSizeParams { - SetSizeParams() {} - ~SetSizeParams() {} - - scoped_ptr enable_auto_size; - scoped_ptr min_size; - scoped_ptr max_size; - scoped_ptr normal_size; -}; - class WebContents : public mate::TrackableObject, - public content::BrowserPluginGuestDelegate, public CommonWebContentsDelegate, public content::WebContentsObserver, public content::GpuDataManagerObserver { @@ -115,18 +100,11 @@ class WebContents : public mate::TrackableObject, bool SendIPCMessage(const base::string16& channel, const base::ListValue& args); - // Used to toggle autosize mode for this GuestView, and set both the automatic - // and normal sizes. + // Methods for creating . void SetSize(const SetSizeParams& params); - - // Sets the transparency of the guest. void SetAllowTransparency(bool allow); - bool IsGuest() const; - // Returns whether this guest has an associated embedder. - bool attached() const { return !!embedder_web_contents_; } - // Returns the current InspectableWebContents object, nullptr will be returned // if current WebContents can not beinspected, e.g. it is the devtools. brightray::InspectableWebContents* inspectable_web_contents() const { @@ -204,7 +182,6 @@ class WebContents : public mate::TrackableObject, const content::LoadCommittedDetails& details, const content::FrameNavigateParams& params) override; bool OnMessageReceived(const IPC::Message& message) override; - void RenderViewReady() override; void WebContentsDestroyed() override; void NavigationEntryCommitted( const content::LoadCommittedDetails& load_details) override; @@ -214,15 +191,6 @@ class WebContents : public mate::TrackableObject, void PluginCrashed(const base::FilePath& plugin_path, base::ProcessId plugin_pid) override; - // content::BrowserPluginGuestDelegate: - void DidAttach(int guest_proxy_routing_id) final; - content::WebContents* GetOwnerWebContents() const final; - void GuestSizeChanged(const gfx::Size& new_size) final; - void SetGuestHost(content::GuestHost* guest_host) final; - void WillAttach(content::WebContents* embedder_web_contents, - int element_instance_id, - bool is_full_page_plugin) final; - // content::GpuDataManagerObserver: void OnGpuProcessCrashed(base::TerminationStatus exit_code) override; @@ -242,49 +210,9 @@ class WebContents : public mate::TrackableObject, const base::ListValue& args, IPC::Message* message); - // This method is invoked when the contents auto-resized to give the container - // an opportunity to match it if it wishes. - // - // This gives the derived class an opportunity to inform its container element - // or perform other actions. - void GuestSizeChangedDueToAutoSize(const gfx::Size& old_size, - const gfx::Size& new_size); - - // Returns the default size of the guestview. - gfx::Size GetDefaultSize() const; - v8::Global session_; - // Stores whether the contents of the guest can be transparent. - bool guest_opaque_; - - // The WebContents that attaches this guest view. - content::WebContents* embedder_web_contents_; - - // The size of the container element. - gfx::Size element_size_; - - // The size of the guest content. Note: In autosize mode, the container - // element may not match the size of the guest. - gfx::Size guest_size_; - - // A pointer to the guest_host. - content::GuestHost* guest_host_; - - // Indicates whether autosize mode is enabled or not. - bool auto_size_enabled_; - - // The maximum size constraints of the container element in autosize mode. - gfx::Size max_auto_size_; - - // The minimum size constraints of the container element in autosize mode. - gfx::Size min_auto_size_; - - // The size that will be used when autosize mode is disabled. - gfx::Size normal_size_; - - // Whether the guest view is inside a plugin document. - bool is_full_page_plugin_; + scoped_ptr guest_delegate_; // The type of current WebContents. Type type_; diff --git a/atom/browser/api/event_emitter.h b/atom/browser/api/event_emitter.h index 43fbd84f61c4..7139b606483c 100644 --- a/atom/browser/api/event_emitter.h +++ b/atom/browser/api/event_emitter.h @@ -25,9 +25,6 @@ class EventEmitter : public Wrappable { public: typedef std::vector> ValueArray; - protected: - EventEmitter(); - // this.emit(name, new Event(), args...); template bool Emit(const base::StringPiece& name, const Args&... args) { @@ -48,6 +45,9 @@ class EventEmitter : public Wrappable { StringToV8(isolate(), "defaultPrevented"))->BooleanValue(); } + protected: + EventEmitter(); + private: v8::Local CreateEvent(v8::Isolate* isolate, content::WebContents* sender, diff --git a/atom/browser/web_view_guest_delegate.cc b/atom/browser/web_view_guest_delegate.cc new file mode 100644 index 000000000000..98fa72da22d4 --- /dev/null +++ b/atom/browser/web_view_guest_delegate.cc @@ -0,0 +1,175 @@ +// Copyright (c) 2015 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#include "atom/browser/web_view_guest_delegate.h" + +#include "atom/browser/api/atom_api_web_contents.h" +#include "content/public/browser/guest_host.h" +#include "content/public/browser/render_view_host.h" +#include "content/public/browser/render_widget_host_view.h" + +namespace atom { + +namespace { + +const int kDefaultWidth = 300; +const int kDefaultHeight = 300; + +} // namespace + +WebViewGuestDelegate::WebViewGuestDelegate() + : guest_opaque_(true), + guest_host_(nullptr), + auto_size_enabled_(false), + is_full_page_plugin_(false), + api_web_contents_(nullptr) { +} + +WebViewGuestDelegate::~WebViewGuestDelegate() { +} + +void WebViewGuestDelegate::Initialize(api::WebContents* api_web_contents) { + api_web_contents_ = api_web_contents; + Observe(api_web_contents->GetWebContents()); +} + +void WebViewGuestDelegate::Destroy() { + // Give the content module an opportunity to perform some cleanup. + guest_host_->WillDestroy(); + guest_host_ = nullptr; +} + +void WebViewGuestDelegate::SetSize(const SetSizeParams& params) { + bool enable_auto_size = + params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_; + gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_; + gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_; + + if (params.normal_size) + normal_size_ = *params.normal_size; + + min_auto_size_ = min_size; + min_auto_size_.SetToMin(max_size); + max_auto_size_ = max_size; + max_auto_size_.SetToMax(min_size); + + enable_auto_size &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty(); + + auto rvh = web_contents()->GetRenderViewHost(); + if (enable_auto_size) { + // Autosize is being enabled. + rvh->EnableAutoResize(min_auto_size_, max_auto_size_); + normal_size_.SetSize(0, 0); + } else { + // Autosize is being disabled. + // Use default width/height if missing from partially defined normal size. + if (normal_size_.width() && !normal_size_.height()) + normal_size_.set_height(GetDefaultSize().height()); + if (!normal_size_.width() && normal_size_.height()) + normal_size_.set_width(GetDefaultSize().width()); + + gfx::Size new_size; + if (!normal_size_.IsEmpty()) { + new_size = normal_size_; + } else if (!guest_size_.IsEmpty()) { + new_size = guest_size_; + } else { + new_size = GetDefaultSize(); + } + + if (auto_size_enabled_) { + // Autosize was previously enabled. + rvh->DisableAutoResize(new_size); + GuestSizeChangedDueToAutoSize(guest_size_, new_size); + } else { + // Autosize was already disabled. + guest_host_->SizeContents(new_size); + } + + guest_size_ = new_size; + } + + auto_size_enabled_ = enable_auto_size; +} + +void WebViewGuestDelegate::SetAllowTransparency(bool allow) { + if (guest_opaque_ != allow) + return; + + auto render_view_host = web_contents()->GetRenderViewHost(); + guest_opaque_ = !allow; + if (!render_view_host->GetView()) + return; + + if (guest_opaque_) { + render_view_host->GetView()->SetBackgroundColorToDefault(); + } else { + render_view_host->GetView()->SetBackgroundColor(SK_ColorTRANSPARENT); + } +} + +void WebViewGuestDelegate::HandleKeyboardEvent( + content::WebContents* source, + const content::NativeWebKeyboardEvent& event) { + if (embedder_web_contents_) + embedder_web_contents_->GetDelegate()->HandleKeyboardEvent(source, event); +} + +void WebViewGuestDelegate::RenderViewReady() { + // We don't want to accidentally set the opacity of an interstitial page. + // WebContents::GetRenderWidgetHostView will return the RWHV of an + // interstitial page if one is showing at this time. We only want opacity + // to apply to web pages. + auto render_view_host_view = web_contents()->GetRenderViewHost()->GetView(); + if (guest_opaque_) + render_view_host_view->SetBackgroundColorToDefault(); + else + render_view_host_view->SetBackgroundColor(SK_ColorTRANSPARENT); +} + +void WebViewGuestDelegate::DidAttach(int guest_proxy_routing_id) { + api_web_contents_->Emit("did-attach"); +} + +content::WebContents* WebViewGuestDelegate::GetOwnerWebContents() const { + return embedder_web_contents_; +} + +void WebViewGuestDelegate::GuestSizeChanged(const gfx::Size& new_size) { + if (!auto_size_enabled_) + return; + GuestSizeChangedDueToAutoSize(guest_size_, new_size); + guest_size_ = new_size; +} + +void WebViewGuestDelegate::SetGuestHost(content::GuestHost* guest_host) { + guest_host_ = guest_host; +} + +void WebViewGuestDelegate::WillAttach( + content::WebContents* embedder_web_contents, + int element_instance_id, + bool is_full_page_plugin) { + embedder_web_contents_ = embedder_web_contents; + is_full_page_plugin_ = is_full_page_plugin; +} + +void WebViewGuestDelegate::GuestSizeChangedDueToAutoSize( + const gfx::Size& old_size, const gfx::Size& new_size) { + api_web_contents_->Emit("size-changed", + old_size.width(), old_size.height(), + new_size.width(), new_size.height()); +} + +gfx::Size WebViewGuestDelegate::GetDefaultSize() const { + if (is_full_page_plugin_) { + // Full page plugins default to the size of the owner's viewport. + return embedder_web_contents_->GetRenderWidgetHostView() + ->GetVisibleViewportSize(); + } else { + return gfx::Size(kDefaultWidth, kDefaultHeight); + } +} + +} // namespace atom diff --git a/atom/browser/web_view_guest_delegate.h b/atom/browser/web_view_guest_delegate.h new file mode 100644 index 000000000000..267b5b248af6 --- /dev/null +++ b/atom/browser/web_view_guest_delegate.h @@ -0,0 +1,122 @@ +// Copyright (c) 2015 GitHub, Inc. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#ifndef ATOM_BROWSER_WEB_VIEW_GUEST_DELEGATE_H_ +#define ATOM_BROWSER_WEB_VIEW_GUEST_DELEGATE_H_ + +#include "content/public/browser/browser_plugin_guest_delegate.h" +#include "content/public/browser/web_contents_observer.h" + +namespace content { +struct NativeWebKeyboardEvent; +} + +namespace atom { + +namespace api { +class WebContents; +} + +// A struct of parameters for SetSize(). The parameters are all declared as +// scoped pointers since they are all optional. Null pointers indicate that the +// parameter has not been provided, and the last used value should be used. Note +// that when |enable_auto_size| is true, providing |normal_size| is not +// meaningful. This is because the normal size of the guestview is overridden +// whenever autosizing occurs. +struct SetSizeParams { + SetSizeParams() {} + ~SetSizeParams() {} + + scoped_ptr enable_auto_size; + scoped_ptr min_size; + scoped_ptr max_size; + scoped_ptr normal_size; +}; + +class WebViewGuestDelegate : public content::BrowserPluginGuestDelegate, + public content::WebContentsObserver { + public: + WebViewGuestDelegate(); + ~WebViewGuestDelegate() override; + + void Initialize(api::WebContents* api_web_contents); + + // Called when the WebContents is going to be destroyed. + void Destroy(); + + // Used to toggle autosize mode for this GuestView, and set both the automatic + // and normal sizes. + void SetSize(const SetSizeParams& params); + + // Sets the transparency of the guest. + void SetAllowTransparency(bool allow); + + // Transfer the keyboard event to embedder. + void HandleKeyboardEvent(content::WebContents* source, + const content::NativeWebKeyboardEvent& event); + + protected: + // content::WebContentsObserver: + void RenderViewReady() override; + + // content::BrowserPluginGuestDelegate: + void DidAttach(int guest_proxy_routing_id) final; + content::WebContents* GetOwnerWebContents() const final; + void GuestSizeChanged(const gfx::Size& new_size) final; + void SetGuestHost(content::GuestHost* guest_host) final; + void WillAttach(content::WebContents* embedder_web_contents, + int element_instance_id, + bool is_full_page_plugin) final; + + private: + // This method is invoked when the contents auto-resized to give the container + // an opportunity to match it if it wishes. + // + // This gives the derived class an opportunity to inform its container element + // or perform other actions. + void GuestSizeChangedDueToAutoSize(const gfx::Size& old_size, + const gfx::Size& new_size); + + // Returns the default size of the guestview. + gfx::Size GetDefaultSize() const; + + // Stores whether the contents of the guest can be transparent. + bool guest_opaque_; + + // The WebContents that attaches this guest view. + content::WebContents* embedder_web_contents_; + + // The size of the container element. + gfx::Size element_size_; + + // The size of the guest content. Note: In autosize mode, the container + // element may not match the size of the guest. + gfx::Size guest_size_; + + // A pointer to the guest_host. + content::GuestHost* guest_host_; + + // Indicates whether autosize mode is enabled or not. + bool auto_size_enabled_; + + // The maximum size constraints of the container element in autosize mode. + gfx::Size max_auto_size_; + + // The minimum size constraints of the container element in autosize mode. + gfx::Size min_auto_size_; + + // The size that will be used when autosize mode is disabled. + gfx::Size normal_size_; + + // Whether the guest view is inside a plugin document. + bool is_full_page_plugin_; + + api::WebContents* api_web_contents_; + + DISALLOW_COPY_AND_ASSIGN(WebViewGuestDelegate); +}; + +} // namespace atom + +#endif // ATOM_BROWSER_WEB_VIEW_GUEST_DELEGATE_H_ diff --git a/filenames.gypi b/filenames.gypi index 4d2ba9c904a2..562e65280d59 100644 --- a/filenames.gypi +++ b/filenames.gypi @@ -207,6 +207,8 @@ 'atom/browser/ui/x/window_state_watcher.h', 'atom/browser/ui/x/x_window_utils.cc', 'atom/browser/ui/x/x_window_utils.h', + 'atom/browser/web_view_guest_delegate.cc', + 'atom/browser/web_view_guest_delegate.h', 'atom/browser/web_view_manager.cc', 'atom/browser/web_view_manager.h', 'atom/browser/web_dialog_helper.cc',