Move GuestView layer in browser to components

components/guest_view/browser/guest_view_manager.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_manager.h"
+#include "components/guest_view/browser/guest_view_manager.h"
 
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
+#include "components/guest_view/browser/guest_view_base.h"
+#include "components/guest_view/browser/guest_view_manager_delegate.h"
+#include "components/guest_view/browser/guest_view_manager_factory.h"
+#include "components/guest_view/common/guest_view_constants.h"
 #include "content/public/browser/browser_context.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/user_metrics.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
-#include "extensions/browser/guest_view/guest_view_base.h"
-#include "extensions/browser/guest_view/guest_view_manager_delegate.h"
-#include "extensions/browser/guest_view/guest_view_manager_factory.h"
-#include "extensions/common/guest_view/guest_view_constants.h"
-#include "net/base/escape.h"
 #include "url/gurl.h"
 
 using content::BrowserContext;
 using content::SiteInstance;
 using content::WebContents;
-using guestview::GuestViewManagerDelegate;
 
-namespace extensions {
+namespace guest_view {
 
 // static
 GuestViewManagerFactory* GuestViewManager::factory_ = nullptr;
 
 GuestViewManager::GuestViewManager(
     content::BrowserContext* context,
     scoped_ptr<GuestViewManagerDelegate> delegate)
     : current_instance_id_(0),
       last_instance_id_removed_(0),
       context_(context),
       delegate_(delegate.Pass()) {
 }
 
 GuestViewManager::~GuestViewManager() {}
 
 // static
 GuestViewManager* GuestViewManager::CreateWithDelegate(
     BrowserContext* context,
     scoped_ptr<GuestViewManagerDelegate> delegate) {
   GuestViewManager* guest_manager = FromBrowserContext(context);
   if (!guest_manager) {
     if (factory_) {
       guest_manager =
           factory_->CreateGuestViewManager(context, delegate.Pass());
     } else {
       guest_manager = new GuestViewManager(context, delegate.Pass());
     }
-    context->SetUserData(guestview::kGuestViewManagerKeyName, guest_manager);
+    context->SetUserData(kGuestViewManagerKeyName, guest_manager);
   }
   return guest_manager;
 }
 
 // static
 GuestViewManager* GuestViewManager::FromBrowserContext(
     BrowserContext* context) {
   return static_cast<GuestViewManager*>(context->GetUserData(
-      guestview::kGuestViewManagerKeyName));
+      kGuestViewManagerKeyName));
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceIDSafely(
     int guest_instance_id,
     int embedder_render_process_id) {
   if (!CanEmbedderAccessInstanceIDMaybeKill(embedder_render_process_id,
                                             guest_instance_id)) {
     return nullptr;
   }
   return GetGuestByInstanceID(guest_instance_id);
@@ skipping 74 matching lines @@
   auto guest_web_contents = WebContents::Create(guest_create_params);
   guest->InitWithWebContents(base::DictionaryValue(), guest_web_contents);
   return guest_web_contents;
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
     int owner_process_id,
     int element_instance_id) {
   int guest_instance_id = GetGuestInstanceIDForElementID(owner_process_id,
                                                          element_instance_id);
-  if (guest_instance_id == guestview::kInstanceIDNone)
+  if (guest_instance_id == kInstanceIDNone)
     return nullptr;
 
   return GetGuestByInstanceID(guest_instance_id);
 }
 
 int GuestViewManager::GetGuestInstanceIDForElementID(int owner_process_id,
                                                      int element_instance_id) {
   auto iter = instance_id_map_.find(
       ElementInstanceKey(owner_process_id, element_instance_id));
   if (iter == instance_id_map_.end())
-    return guestview::kInstanceIDNone;
+    return kInstanceIDNone;
   return iter->second;
 }
 
 SiteInstance* GuestViewManager::GetGuestSiteInstance(
     const GURL& guest_site) {
   for (const auto& guest : guest_web_contents_by_instance_id_) {
     if (guest.second->GetSiteInstance()->GetSiteURL() == guest_site)
       return guest.second->GetSiteInstance();
   }
   return nullptr;
@@ skipping 83 matching lines @@
 }
 
 bool GuestViewManager::IsGuestAvailableToContext(GuestViewBase* guest) {
   return delegate_->IsGuestAvailableToContext(guest);
 }
 
 void GuestViewManager::DispatchEvent(const std::string& event_name,
                                      scoped_ptr<base::DictionaryValue> args,
                                      GuestViewBase* guest,
                                      int instance_id) {
+  // TODO(fsamuel): GuestViewManager should probably do something more useful
+  // here like log an error if the event could not be dispatched.
   delegate_->DispatchEvent(event_name, args.Pass(), guest, instance_id);
 }
 
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
     int guest_instance_id) {
   auto it = guest_web_contents_by_instance_id_.find(guest_instance_id);
   if (it == guest_web_contents_by_instance_id_.end())
     return nullptr;
   return it->second;
 }
@@ skipping 29 matching lines @@
     return true;
   }
   return false;
 }
 
 bool GuestViewManager::CanEmbedderAccessInstanceID(
     int embedder_render_process_id,
     int guest_instance_id) {
   // The embedder is trying to access a guest with a negative or zero
   // instance ID.
-  if (guest_instance_id <= guestview::kInstanceIDNone)
+  if (guest_instance_id <= kInstanceIDNone)
     return false;
 
   // The embedder is trying to access an instance ID that has not yet been
   // allocated by GuestViewManager. This could cause instance ID
   // collisions in the future, and potentially give one embedder access to a
   // guest it does not own.
   if (guest_instance_id > current_instance_id_)
     return false;
 
   // We might get some late arriving messages at tear down. Let's let the
@@ skipping 29 matching lines @@
 
   return element_instance_id < other.element_instance_id;
 }
 
 bool GuestViewManager::ElementInstanceKey::operator==(
     const GuestViewManager::ElementInstanceKey& other) const {
   return (embedder_process_id == other.embedder_process_id) &&
     (element_instance_id == other.element_instance_id);
 }
 
-}  // namespace extensions
+}  // namespace guest_view