Towards moving guest management to chrome: Introduce GuestViewManager

chrome/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 "chrome/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "chrome/browser/guest_view/ad_view/ad_view_guest.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
+#include "chrome/browser/guest_view/guest_view_manager.h"
 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/content_settings.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/event_router.h"
 #include "net/base/escape.h"
 
 using content::WebContents;
 
 namespace {
 
-// <embedder_process_id, guest_instance_id> => GuestViewBase*
-typedef std::map<std::pair<int, int>, GuestViewBase*> EmbedderGuestViewMap;
-static base::LazyInstance<EmbedderGuestViewMap> embedder_guestview_map =
-    LAZY_INSTANCE_INITIALIZER;
-
 typedef std::map<WebContents*, GuestViewBase*> WebContentsGuestViewMap;
 static base::LazyInstance<WebContentsGuestViewMap> webcontents_guestview_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 GuestViewBase::Event::Event(const std::string& name,
                             scoped_ptr<base::DictionaryValue> args)
     : name_(name), args_(args.Pass()) {
 }
 
 GuestViewBase::Event::~Event() {
 }
 
 scoped_ptr<base::DictionaryValue> GuestViewBase::Event::GetArguments() {
   return args_.Pass();
 }
 
 GuestViewBase::GuestViewBase(WebContents* guest_web_contents,
-                             const std::string& embedder_extension_id)
+                             const std::string& embedder_extension_id,
+                             const base::WeakPtr<GuestViewBase>& opener)
     : guest_web_contents_(guest_web_contents),
       embedder_web_contents_(NULL),
       embedder_extension_id_(embedder_extension_id),
       embedder_render_process_id_(0),
       browser_context_(guest_web_contents->GetBrowserContext()),
       guest_instance_id_(guest_web_contents->GetEmbeddedInstanceID()),
       view_instance_id_(guestview::kInstanceIDNone),
+      opener_(opener),
       weak_ptr_factory_(this) {
   webcontents_guestview_map.Get().insert(
       std::make_pair(guest_web_contents, this));
 }
 
 // static
-GuestViewBase* GuestViewBase::Create(WebContents* guest_web_contents,
-                                     const std::string& embedder_extension_id,
-                                     const std::string& view_type) {
+GuestViewBase* GuestViewBase::Create(
+    WebContents* guest_web_contents,
+    const std::string& embedder_extension_id,
+    const std::string& view_type,
+    const base::WeakPtr<GuestViewBase>& opener) {
   if (view_type == "webview") {
-    return new WebViewGuest(guest_web_contents, embedder_extension_id);
+    return new WebViewGuest(guest_web_contents, embedder_extension_id, opener);
   } else if (view_type == "adview") {
     return new AdViewGuest(guest_web_contents, embedder_extension_id);
   }
   NOTREACHED();
   return NULL;
 }
 
 // static
 GuestViewBase* GuestViewBase::FromWebContents(WebContents* web_contents) {
   WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer();
   WebContentsGuestViewMap::iterator it = guest_map->find(web_contents);
   return it == guest_map->end() ? NULL : it->second;
 }
 
 // static
 GuestViewBase* GuestViewBase::From(int embedder_process_id,
                                    int guest_instance_id) {
-  EmbedderGuestViewMap* guest_map = embedder_guestview_map.Pointer();
-  EmbedderGuestViewMap::iterator it =
-      guest_map->find(std::make_pair(embedder_process_id, guest_instance_id));
-  return it == guest_map->end() ? NULL : it->second;
+  content::RenderProcessHost* host =
+      content::RenderProcessHost::FromID(embedder_process_id);
+  if (!host)
+    return NULL;
+
+  content::WebContents* guest_web_contents =
+      GuestViewManager::FromBrowserContext(host->GetBrowserContext())->
+          GetGuestByInstanceID(guest_instance_id, embedder_process_id);
+  if (!guest_web_contents)
+    return NULL;
+
+  return GuestViewBase::FromWebContents(guest_web_contents);
 }
 
 // static
 bool GuestViewBase::GetGuestPartitionConfigForSite(
     const GURL& site,
     std::string* partition_domain,
     std::string* partition_name,
     bool* in_memory) {
   if (!site.SchemeIs(content::kGuestScheme))
     return false;
@@ skipping 24 matching lines @@
                                   incognito));
 
   rules->script_rules.push_back(
       ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
                                   ContentSettingsPattern::Wildcard(),
                                   CONTENT_SETTING_ALLOW,
                                   std::string(),
                                   incognito));
 }
 
+base::WeakPtr<GuestViewBase> GuestViewBase::AsWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
 void GuestViewBase::Attach(content::WebContents* embedder_web_contents,
                            const base::DictionaryValue& args) {
   embedder_web_contents_ = embedder_web_contents;
   embedder_render_process_id_ =
       embedder_web_contents->GetRenderProcessHost()->GetID();
   args.GetInteger(guestview::kParameterInstanceId, &view_instance_id_);
 
   std::pair<int, int> key(embedder_render_process_id_, guest_instance_id_);
-  embedder_guestview_map.Get().insert(std::make_pair(key, this));
 
   // GuestViewBase::Attach is called prior to initialization (and initial
   // navigation) of the guest in the content layer in order to permit mapping
   // the necessary associations between the <*view> element and its guest. This
   // is needed by the <webview> WebRequest API to allow intercepting resource
   // requests during navigation. However, queued events should be fired after
   // content layer initialization in order to ensure that load events (such as
   // 'loadstop') fire in embedder after the contentWindow is available.
   if (!in_extension())
     return;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GuestViewBase::SendQueuedEvents,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+WebContents* GuestViewBase::GetOpener() const {
+  if (!opener_)
+    return NULL;
+  return opener_->guest_web_contents();
+}
+
+void GuestViewBase::SetOpener(WebContents* web_contents) {
+  GuestViewBase* guest = FromWebContents(web_contents);
+  if (guest && guest->IsViewType(GetViewType())) {
+    opener_ = guest->AsWeakPtr();
+    return;
+  }
+  opener_ = base::WeakPtr<GuestViewBase>();
+}
+
 GuestViewBase::~GuestViewBase() {
   std::pair<int, int> key(embedder_render_process_id_, guest_instance_id_);
-  embedder_guestview_map.Get().erase(key);
 
   webcontents_guestview_map.Get().erase(guest_web_contents());
 
   pending_events_.clear();
 }
 
 void GuestViewBase::DispatchEvent(Event* event) {
   scoped_ptr<Event> event_ptr(event);
   if (!in_extension()) {
     NOTREACHED();
@@ skipping 26 matching lines @@
 void GuestViewBase::SendQueuedEvents() {
   if (!attached())
     return;
 
   while (!pending_events_.empty()) {
     linked_ptr<Event> event_ptr = pending_events_.front();
     pending_events_.pop_front();
     DispatchEvent(event_ptr.release());
   }
 }