Towards moving guest management to chrome: Introduce GuestViewManager

content/browser/browser_plugin/browser_plugin_guest.cc

 // Copyright (c) 2012 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 "content/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 80 matching lines @@
       : PermissionRequest(guest),
         instance_id_(instance_id) {
     RecordAction(
         base::UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.NewWindow"));
   }
 
   virtual void RespondImpl(bool should_allow,
                            const std::string& user_input) OVERRIDE {
     int embedder_render_process_id =
         guest_->embedder_web_contents()->GetRenderProcessHost()->GetID();
-    BrowserPluginGuest* guest =
-        guest_->GetWebContents()->GetBrowserPluginGuestManager()->
-            GetGuestByInstanceID(instance_id_, embedder_render_process_id);
+    BrowserPluginGuest* guest = guest_->GetBrowserPluginGuestManager()->
+        GetGuestByInstanceID(instance_id_, embedder_render_process_id);
     if (!guest) {
       VLOG(0) << "Guest not found. Instance ID: " << instance_id_;
       return;
     }
 
     // If we do not destroy the guest then we allow the new window.
     if (!should_allow)
       guest->Destroy();
   }
 
@@ skipping 68 matching lines @@
 
  private:
   BrowserPluginGuest* browser_plugin_guest_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedderWebContentsObserver);
 };
 
 BrowserPluginGuest::BrowserPluginGuest(
     int instance_id,
     bool has_render_view,
-    WebContentsImpl* web_contents,
-    BrowserPluginGuest* opener)
+    WebContentsImpl* web_contents)
     : WebContentsObserver(web_contents),
       embedder_web_contents_(NULL),
       instance_id_(instance_id),
       guest_device_scale_factor_(1.0f),
       guest_hang_timeout_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       focused_(false),
       mouse_locked_(false),
       pending_lock_request_(false),
       embedder_visible_(true),
       auto_size_enabled_(false),
       copy_request_id_(0),
       next_permission_request_id_(browser_plugin::kInvalidPermissionRequestID),
       has_render_view_(has_render_view),
       last_seen_auto_size_enabled_(false),
       is_in_destruction_(false),
       last_text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       last_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       last_can_compose_inline_(true),
       weak_ptr_factory_(this) {
   DCHECK(web_contents);
   web_contents->SetDelegate(this);
-  if (opener)
-    opener_ = opener->AsWeakPtr();
-  GetWebContents()->GetBrowserPluginGuestManager()->AddGuest(instance_id_,
-                                                             GetWebContents());
+  GetBrowserPluginGuestManager()->AddGuest(instance_id_, GetWebContents());
 }
 
 bool BrowserPluginGuest::AddMessageToConsole(WebContents* source,
                                              int32 level,
                                              const base::string16& message,
                                              int32 line_no,
                                              const base::string16& source_id) {
   if (!delegate_)
     return false;
 
@@ skipping 65 matching lines @@
   BrowserPluginGuestDelegate::PermissionResponseCallback callback =
       base::Bind(&BrowserPluginGuest::RespondToPermissionRequest,
                   AsWeakPtr(),
                   request_id);
   delegate_->RequestPermission(
       permission_type, request_info, callback, request->AllowedByDefault());
 }
 
 BrowserPluginGuest* BrowserPluginGuest::CreateNewGuestWindow(
     const OpenURLParams& params) {
-  BrowserPluginGuestManager* guest_manager =
-      GetWebContents()->GetBrowserPluginGuestManager();
+  BrowserPluginGuestManager* guest_manager = GetBrowserPluginGuestManager();
 
   // Allocate a new instance ID for the new guest.
-  int instance_id = guest_manager->get_next_instance_id();
+  int instance_id = guest_manager->GetNextInstanceID();
 
   // Set the attach params to use the same partition as the opener.
   // We pull the partition information from the site's URL, which is of the form
   // guest://site/{persist}?{partition_name}.
   const GURL& site_url = GetWebContents()->GetSiteInstance()->GetSiteURL();
   BrowserPluginHostMsg_Attach_Params attach_params;
   attach_params.storage_partition_id = site_url.query();
   attach_params.persist_storage =
       site_url.path().find("persist") != std::string::npos;
 
   // The new guest gets a copy of this guest's extra params so that the content
   // embedder exposes the same API for this guest as its opener.
   scoped_ptr<base::DictionaryValue> extra_params(
       extra_attach_params_->DeepCopy());
   BrowserPluginGuest* new_guest =
-      GetWebContents()->GetBrowserPluginGuestManager()->CreateGuest(
-          GetWebContents()->GetSiteInstance(), instance_id,
-          attach_params, extra_params.Pass());
-  new_guest->opener_ = AsWeakPtr();
+      guest_manager->CreateGuest(GetWebContents()->GetSiteInstance(),
+                                 instance_id,
+                                 attach_params,
+                                 extra_params.Pass());
+  if (new_guest->delegate_)
+    new_guest->delegate_->SetOpener(GetWebContents());
 
   // Take ownership of |new_guest|.
   pending_new_windows_.insert(
       std::make_pair(new_guest, NewWindowInfo(params.url, std::string())));
 
   // Request permission to show the new window.
   RequestNewWindowPermission(params.disposition, gfx::Rect(),
                              params.user_gesture, new_guest->GetWebContents());
 
   return new_guest;
 }
 
 base::WeakPtr<BrowserPluginGuest> BrowserPluginGuest::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void BrowserPluginGuest::EmbedderDestroyed() {
   embedder_web_contents_ = NULL;
   if (delegate_)
     delegate_->EmbedderDestroyed();
   Destroy();
 }
 
 void BrowserPluginGuest::Destroy() {
   is_in_destruction_ = true;
-  if (!attached() && opener())
-    opener()->pending_new_windows_.erase(this);
+  if (!attached() && GetOpener())
+    GetOpener()->pending_new_windows_.erase(this);
   DestroyUnattachedWindows();
-  GetWebContents()->GetBrowserPluginGuestManager()->RemoveGuest(instance_id_);
+  GetBrowserPluginGuestManager()->RemoveGuest(instance_id_);
   delete GetWebContents();
 }
 
 bool BrowserPluginGuest::OnMessageReceivedFromEmbedder(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPluginGuest, message)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_CompositorFrameSwappedACK,
                         OnCompositorFrameSwappedACK)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_CopyFromCompositingSurfaceAck,
@@ skipping 134 matching lines @@
 BrowserPluginGuest* BrowserPluginGuest::Create(
     int instance_id,
     SiteInstance* guest_site_instance,
     WebContentsImpl* web_contents,
     scoped_ptr<base::DictionaryValue> extra_params) {
   RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Create"));
   BrowserPluginGuest* guest = NULL;
   if (factory_) {
     guest = factory_->CreateBrowserPluginGuest(instance_id, web_contents);
   } else {
-    guest = new BrowserPluginGuest(instance_id, false, web_contents, NULL);
+    guest = new BrowserPluginGuest(instance_id, false, web_contents);
   }
   guest->extra_attach_params_.reset(extra_params->DeepCopy());
   web_contents->SetBrowserPluginGuest(guest);
   BrowserPluginGuestDelegate* delegate = NULL;
   GetContentClient()->browser()->GuestWebContentsCreated(
       guest_site_instance, web_contents, NULL, &delegate, extra_params.Pass());
   guest->SetDelegate(delegate);
   return guest;
 }
 
 // static
 BrowserPluginGuest* BrowserPluginGuest::CreateWithOpener(
     int instance_id,
     bool has_render_view,
     WebContentsImpl* web_contents,
     BrowserPluginGuest* opener) {
   BrowserPluginGuest* guest =
       new BrowserPluginGuest(
-          instance_id, has_render_view, web_contents, opener);
+          instance_id, has_render_view, web_contents);
   web_contents->SetBrowserPluginGuest(guest);
   BrowserPluginGuestDelegate* delegate = NULL;
   GetContentClient()->browser()->GuestWebContentsCreated(
       opener->GetWebContents()->GetSiteInstance(),
       web_contents, opener->GetWebContents(), &delegate,
       scoped_ptr<base::DictionaryValue>());
   guest->SetDelegate(delegate);
   return guest;
 }
 
 RenderWidgetHostView* BrowserPluginGuest::GetEmbedderRenderWidgetHostView() {
   if (!attached())
     return NULL;
   return embedder_web_contents_->GetRenderWidgetHostView();
 }
 
+BrowserPluginGuest* BrowserPluginGuest::GetOpener() const {
+  if (!delegate_)
+    return NULL;
+
+  WebContents* opener = delegate_->GetOpener();
+  if (!opener)
+    return NULL;
+
+  return static_cast<WebContentsImpl*>(opener)->GetBrowserPluginGuest();
+}
+
 void BrowserPluginGuest::UpdateVisibility() {
   OnSetVisibility(instance_id_, visible());
 }
 
 void BrowserPluginGuest::CopyFromCompositingSurface(
       gfx::Rect src_subrect,
       gfx::Size dst_size,
       const base::Callback<void(bool, const SkBitmap&)>& callback) {
   copy_request_callbacks_.insert(std::make_pair(++copy_request_id_, callback));
   SendMessageToEmbedder(
       new BrowserPluginMsg_CopyFromCompositingSurface(instance_id(),
           copy_request_id_, src_subrect, dst_size));
 }
 
+BrowserPluginGuestManager*
+BrowserPluginGuest::GetBrowserPluginGuestManager() const {
+  return BrowserPluginGuestManager::FromBrowserContext(
+      GetWebContents()->GetBrowserContext());
+}
+
 // screen.
 gfx::Rect BrowserPluginGuest::ToGuestRect(const gfx::Rect& bounds) {
   gfx::Rect guest_rect(bounds);
   guest_rect.Offset(guest_window_rect_.OffsetFromOrigin());
   return guest_rect;
 }
 
 void BrowserPluginGuest::EmbedderVisibilityChanged(bool visible) {
   embedder_visible_ = visible;
   UpdateVisibility();
@@ skipping 125 matching lines @@
 }
 
 WebContents* BrowserPluginGuest::OpenURLFromTab(WebContents* source,
                                                 const OpenURLParams& params) {
   // If the guest wishes to navigate away prior to attachment then we save the
   // navigation to perform upon attachment. Navigation initializes a lot of
   // state that assumes an embedder exists, such as RenderWidgetHostViewGuest.
   // Navigation also resumes resource loading which we don't want to allow
   // until attachment.
   if (!attached()) {
-    PendingWindowMap::iterator it = opener()->pending_new_windows_.find(this);
-    if (it == opener()->pending_new_windows_.end())
+    PendingWindowMap::iterator it =
+        GetOpener()->pending_new_windows_.find(this);
+    if (it == GetOpener()->pending_new_windows_.end())
       return NULL;
     const NewWindowInfo& old_target_url = it->second;
     NewWindowInfo new_window_info(params.url, old_target_url.name);
     new_window_info.changed = new_window_info.url != old_target_url.url;
     it->second = new_window_info;
     return NULL;
   }
   if (params.disposition == CURRENT_TAB) {
     // This can happen for cross-site redirects.
     LoadURLWithParams(params.url, params.referrer, params.transition, source);
     return source;
   }
 
   return CreateNewGuestWindow(params)->GetWebContents();
 }
 
 void BrowserPluginGuest::WebContentsCreated(WebContents* source_contents,
                                             int opener_render_frame_id,
                                             const base::string16& frame_name,
                                             const GURL& target_url,
                                             WebContents* new_contents) {
   WebContentsImpl* new_contents_impl =
       static_cast<WebContentsImpl*>(new_contents);
   BrowserPluginGuest* guest = new_contents_impl->GetBrowserPluginGuest();
-  guest->opener_ = AsWeakPtr();
+  if (guest->delegate_)
+    guest->delegate_->SetOpener(GetWebContents());
   std::string guest_name = base::UTF16ToUTF8(frame_name);
   guest->name_ = guest_name;
   // Take ownership of the new guest until it is attached to the embedder's DOM
   // tree to avoid leaking a guest if this guest is destroyed before attaching
   // the new guest.
   pending_new_windows_.insert(
       std::make_pair(guest, NewWindowInfo(target_url, guest_name)));
 }
 
 void BrowserPluginGuest::RendererUnresponsive(WebContents* source) {
@@ skipping 20 matching lines @@
 
   embedder_web_contents_->GetDelegate()->RunFileChooser(web_contents, params);
 }
 
 bool BrowserPluginGuest::ShouldFocusPageAfterCrash() {
   // Rather than managing focus in WebContentsImpl::RenderViewReady, we will
   // manage the focus ourselves.
   return false;
 }
 
-WebContentsImpl* BrowserPluginGuest::GetWebContents() {
+WebContentsImpl* BrowserPluginGuest::GetWebContents() const {
   return static_cast<WebContentsImpl*>(web_contents());
 }
 
 gfx::Point BrowserPluginGuest::GetScreenCoordinates(
     const gfx::Point& relative_position) const {
   gfx::Point screen_pos(relative_position);
   screen_pos += guest_window_rect_.OffsetFromOrigin();
   return screen_pos;
 }
 
@@ skipping 235 matching lines @@
         GetWebContents()->GetRenderViewHost())->Init();
     WebContentsViewGuest* new_view =
         static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
     new_view->CreateViewForWidget(web_contents()->GetRenderViewHost());
   }
 
   // We need to do a navigation here if the target URL has changed between
   // the time the WebContents was created and the time it was attached.
   // We also need to do an initial navigation if a RenderView was never
   // created for the new window in cases where there is no referrer.
-  PendingWindowMap::iterator it = opener()->pending_new_windows_.find(this);
-  if (it != opener()->pending_new_windows_.end()) {
+  PendingWindowMap::iterator it = GetOpener()->pending_new_windows_.find(this);
+  if (it != GetOpener()->pending_new_windows_.end()) {
     const NewWindowInfo& new_window_info = it->second;
     if (new_window_info.changed || !has_render_view_)
       params.src = it->second.url.spec();
   } else {
     NOTREACHED();
   }
 
   // Once a new guest is attached to the DOM of the embedder page, then the
   // lifetime of the new guest is no longer managed by the opener guest.
-  opener()->pending_new_windows_.erase(this);
+  GetOpener()->pending_new_windows_.erase(this);
 
   // The guest's frame name takes precedence over the BrowserPlugin's name.
   // The guest's frame name is assigned in
   // BrowserPluginGuest::WebContentsCreated.
   if (!name_.empty())
     params.name.clear();
 
   Initialize(params, embedder_web_contents);
 
   SendQueuedMessages();
@@ skipping 480 matching lines @@
     const GURL& url) {
   if (!url.is_valid()) {
     callback.Run(false);
     return;
   }
 
   delegate_->CanDownload(request_method, url, callback);
 }
 
 }  // namespace content