GuestView: Move GuestViewManager extension dependencies to ExtensionsGuestViewManagerDelegate

extensions/browser/guest_view/guest_view_base.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ui/zoom/page_zoom.h"
 #include "components/ui/zoom/zoom_controller.h"
@@ skipping 128 matching lines @@
  private:
   GuestViewBase* guest_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenerLifetimeObserver);
 };
 
 GuestViewBase::GuestViewBase(content::WebContents* owner_web_contents)
     : owner_web_contents_(owner_web_contents),
       browser_context_(owner_web_contents->GetBrowserContext()),
       guest_instance_id_(
-          GuestViewManager::FromBrowserContextIfAvailable(browser_context_)->
+          GuestViewManager::FromBrowserContext(browser_context_)->
               GetNextInstanceID()),
       view_instance_id_(guestview::kInstanceIDNone),
       element_instance_id_(guestview::kInstanceIDNone),
       initialized_(false),
       is_being_destroyed_(false),
       guest_host_(nullptr),
       auto_size_enabled_(false),
       is_full_page_plugin_(false),
       guest_proxy_routing_id_(MSG_ROUTING_NONE),
       weak_ptr_factory_(this) {
+  owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
+      IsOwnedByExtension(this) ?
+          owner_web_contents->GetLastCommittedURL().host() : std::string();
 }
 
 void GuestViewBase::Init(const base::DictionaryValue& create_params,
                          const WebContentsCreatedCallback& callback) {
   if (initialized_)
     return;
   initialized_ = true;
 
-  if (!GuestViewManager::FromBrowserContextIfAvailable(browser_context_)->
-          IsGuestAvailableToContext(this, &owner_extension_id_)) {
+  if (!GuestViewManager::FromBrowserContext(browser_context_)->
+          IsGuestAvailableToContext(this)) {
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
     delete this;
     callback.Run(nullptr);
     return;
   }
 
   scoped_ptr<base::DictionaryValue> params(create_params.DeepCopy());
   CreateWebContents(create_params,
                     base::Bind(&GuestViewBase::CompleteInit,
@@ skipping 21 matching lines @@
   // At this point, we have just created the guest WebContents, we need to add
   // an observer to the owner WebContents. This observer will be responsible
   // for destroying the guest WebContents if the owner goes away.
   owner_contents_observer_.reset(
       new OwnerContentsObserver(this, owner_web_contents_));
 
   WebContentsObserver::Observe(guest_web_contents);
   guest_web_contents->SetDelegate(this);
   webcontents_guestview_map.Get().insert(
       std::make_pair(guest_web_contents, this));
-  GuestViewManager::FromBrowserContextIfAvailable(browser_context_)->
+  GuestViewManager::FromBrowserContext(browser_context_)->
       AddGuest(guest_instance_id_, guest_web_contents);
 
   // Populate the view instance ID if we have it on creation.
   create_params.GetInteger(guestview::kParameterInstanceId,
                            &view_instance_id_);
 
   if (CanRunInDetachedState())
     SetUpSizing(create_params);
 
   // Observe guest zoom changes.
@@ skipping 102 matching lines @@
 }
 
 // static
 GuestViewBase* GuestViewBase::From(int owner_process_id,
                                    int guest_instance_id) {
   auto host = content::RenderProcessHost::FromID(owner_process_id);
   if (!host)
     return nullptr;
 
   content::WebContents* guest_web_contents =
-      GuestViewManager::FromBrowserContextIfAvailable(
+      GuestViewManager::FromBrowserContext(
           host->GetBrowserContext())->
               GetGuestByInstanceIDSafely(guest_instance_id, owner_process_id);
   if (!guest_web_contents)
     return nullptr;
 
   return GuestViewBase::FromWebContents(guest_web_contents);
 }
 
 // static
 WebContents* GuestViewBase::GetTopLevelWebContents(WebContents* web_contents) {
@@ skipping 18 matching lines @@
 bool GuestViewBase::IsDragAndDropEnabled() const {
   return false;
 }
 
 bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
   return true;
 }
 
 content::WebContents* GuestViewBase::CreateNewGuestWindow(
     const content::WebContents::CreateParams& create_params) {
-  auto guest_manager =
-      GuestViewManager::FromBrowserContextIfAvailable(browser_context());
+  auto guest_manager = GuestViewManager::FromBrowserContext(browser_context());
   return guest_manager->CreateGuestWithWebContentsParams(
       GetViewType(),
       owner_web_contents(),
       create_params);
 }
 
 void GuestViewBase::DidAttach(int guest_proxy_routing_id) {
   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
          guest_proxy_routing_id == guest_proxy_routing_id_);
   guest_proxy_routing_id_ = guest_proxy_routing_id;
 
   opener_lifetime_observer_.reset();
 
   SetUpSizing(*attach_params());
 
   // Give the derived class an opportunity to perform some actions.
   DidAttachToEmbedder();
 
   // Inform the associated GuestViewContainer that the contentWindow is ready.
   embedder_web_contents()->Send(new GuestViewMsg_GuestAttached(
       element_instance_id_,
       guest_proxy_routing_id));
 
   SendQueuedEvents();
 }
 
 void GuestViewBase::DidDetach() {
-  GuestViewManager::FromBrowserContextIfAvailable(browser_context_)->
-      DetachGuest(this);
+  GuestViewManager::FromBrowserContext(browser_context_)->DetachGuest(this);
   StopTrackingEmbedderZoomLevel();
   owner_web_contents()->Send(new GuestViewMsg_GuestDetached(
       element_instance_id_));
   element_instance_id_ = guestview::kInstanceIDNone;
 }
 
 WebContents* GuestViewBase::GetOwnerWebContents() const {
   return owner_web_contents_;
 }
 
@@ skipping 29 matching lines @@
   // Invalidate weak pointers now so that bound callbacks cannot be called late
   // into destruction. We must call this after WillDestroy because derived types
   // may wish to access their openers.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Give the content module an opportunity to perform some cleanup.
   guest_host_->WillDestroy();
   guest_host_ = nullptr;
 
   webcontents_guestview_map.Get().erase(web_contents());
-  GuestViewManager::FromBrowserContextIfAvailable(browser_context_)->
+  GuestViewManager::FromBrowserContext(browser_context_)->
       RemoveGuest(guest_instance_id_);
   pending_events_.clear();
 
   delete web_contents();
 }
 
 void GuestViewBase::SetAttachParams(const base::DictionaryValue& params) {
   attach_params_.reset(params.DeepCopy());
   attach_params_->GetInteger(guestview::kParameterInstanceId,
                              &view_instance_id_);
@@ skipping 17 matching lines @@
 void GuestViewBase::WillAttach(content::WebContents* embedder_web_contents,
                                int element_instance_id,
                                bool is_full_page_plugin) {
   if (owner_web_contents_ != embedder_web_contents) {
     DCHECK_EQ(owner_contents_observer_->web_contents(), owner_web_contents_);
     // Stop tracking the old embedder's zoom level.
     StopTrackingEmbedderZoomLevel();
     owner_web_contents_ = embedder_web_contents;
     owner_contents_observer_.reset(
         new OwnerContentsObserver(this, embedder_web_contents));
+    owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
+        IsOwnedByExtension(this) ?
+            owner_web_contents()->GetLastCommittedURL().host() : std::string();
   }
 
   // Start tracking the new embedder's zoom level.
   StartTrackingEmbedderZoomLevel();
   element_instance_id_ = element_instance_id;
   is_full_page_plugin_ = is_full_page_plugin;
 
   WillAttachToEmbedder();
 }
 
@@ skipping 306 matching lines @@
 
   auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   embedder_zoom_controller->RemoveObserver(this);
 }
 
 }  // namespace extensions