<webview>: Make contentWindow available prior to attachment (on display:none).

extensions/browser/guest_view/guest_view_base.h

 // 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 EXTENSIONS_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_
 #define EXTENSIONS_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_
 
 #include <queue>
 
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "components/ui/zoom/zoom_observer.h"
 #include "content/public/browser/browser_plugin_guest_delegate.h"
-#include "content/public/browser/guest_sizer.h"
+#include "content/public/browser/guest_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
 
 struct RendererContentSettingRules;
 
 namespace extensions {
 
@@ skipping 166 matching lines @@
       const WebContentsCreatedCallback& callback) = 0;
 
   // This creates a WebContents and initializes |this| GuestViewBase to use the
   // newly created WebContents.
   void Init(const base::DictionaryValue& create_params,
             const WebContentsCreatedCallback& callback);
 
   void InitWithWebContents(const base::DictionaryValue& create_params,
                            content::WebContents* guest_web_contents);
 
+  void LoadURLWithParams(
+      const content::NavigationController::LoadURLParams& load_params);
+
   bool IsViewType(const char* const view_type) const {
     return !strcmp(GetViewType(), view_type);
   }
 
   // Used to toggle autosize mode for this GuestView, and set both the automatic
   // and normal sizes.
   void SetSize(const SetSizeParams& params);
 
   bool initialized() const { return initialized_; }
 
   content::WebContents* embedder_web_contents() const {
     return attached() ? owner_web_contents_ : nullptr;
   }
 
   content::WebContents* owner_web_contents() const {
     return owner_web_contents_;
   }
 
+  content::GuestHost* host() const {
+    return guest_host_;
+  }
+
   // Returns the parameters associated with the element hosting this GuestView
   // passed in from JavaScript.
   base::DictionaryValue* attach_params() const { return attach_params_.get(); }
 
   // Returns whether this guest has an associated embedder.
   bool attached() const {
     return element_instance_id_ != guestview::kInstanceIDNone;
   }
 
   // Returns the instance ID of the <*view> element.
@@ skipping 21 matching lines @@
   GuestViewBase* GetOpener() const {
     return opener_.get();
   }
 
   // Returns the URL of the owner WebContents.
   const GURL& GetOwnerSiteURL() const;
 
   // Whether the guest view is inside a plugin document.
   bool is_full_page_plugin() { return is_full_page_plugin_; }
 
+  // Returns the routing ID of the guest proxy in the owner's renderer process.
+  // This value is only valid after attachment or first navigation.
+  int proxy_routing_id() const { return guest_proxy_routing_id_; }
+
   // Destroy this guest.
   void Destroy();
 
   // Saves the attach state of the custom element hosting this GuestView.
   void SetAttachParams(const base::DictionaryValue& params);
   void SetOpener(GuestViewBase* opener);
 
   // BrowserPluginGuestDelegate implementation.
   content::WebContents* CreateNewGuestWindow(
       const content::WebContents::CreateParams& create_params) final;
   void DidAttach(int guest_proxy_routing_id) final;
   void DidDetach() final;
   content::WebContents* GetOwnerWebContents() const final;
   void GuestSizeChanged(const gfx::Size& new_size) final;
-  void RegisterDestructionCallback(const DestructionCallback& callback) final;
-  void SetGuestSizer(content::GuestSizer* guest_sizer) final;
+  void SetGuestHost(content::GuestHost* guest_host) final;
   void WillAttach(content::WebContents* embedder_web_contents,
                   int browser_plugin_instance_id,
                   bool is_full_page_plugin) final;
 
   // ui_zoom::ZoomObserver implementation.
   void OnZoomChanged(
       const ui_zoom::ZoomController::ZoomChangedEventData& data) override;
 
   // Dispatches an event to the guest proxy.
   void DispatchEventToGuestProxy(Event* event);
@@ skipping 103 matching lines @@
   // Indicates that this guest is in the process of being destroyed.
   bool is_being_destroyed_;
 
   // This is a queue of Events that are destined to be sent to the embedder once
   // the guest is attached to a particular embedder.
   std::deque<linked_ptr<Event> > pending_events_;
 
   // The opener guest view.
   base::WeakPtr<GuestViewBase> opener_;
 
-  DestructionCallback destruction_callback_;
-
   // The parameters associated with the element hosting this GuestView that
   // are passed in from JavaScript. This will typically be the view instance ID,
   // and element-specific parameters. These parameters are passed along to new
   // guests that are created from this guest.
   scoped_ptr<base::DictionaryValue> attach_params_;
 
   // This observer ensures that this guest self-destructs if the embedder goes
   // away.
   scoped_ptr<OwnerLifetimeObserver> owner_lifetime_observer_;
 
   // This observer ensures that if the guest is unattached and its opener goes
   // away then this guest also self-destructs.
   scoped_ptr<OpenerLifetimeObserver> opener_lifetime_observer_;
 
   // 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_sizer.
-  content::GuestSizer* guest_sizer_;
+  // 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_;
 
+  // The routing ID of the proxy to the guest in the owner's renderer process.
+  int guest_proxy_routing_id_;
+
   // This is used to ensure pending tasks will not fire after this object is
   // destroyed.
   base::WeakPtrFactory<GuestViewBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GuestViewBase);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_