Move GuestView layer in browser to components

components/guest_view/browser/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 "components/guest_view/browser/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
+#include "components/guest_view/browser/guest_view_event.h"
+#include "components/guest_view/browser/guest_view_manager.h"
+#include "components/guest_view/common/guest_view_constants.h"
+#include "components/guest_view/common/guest_view_messages.h"
 #include "components/ui/zoom/page_zoom.h"
 #include "components/ui/zoom/zoom_controller.h"
 #include "content/public/browser/navigation_details.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/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
-#include "extensions/browser/guest_view/guest_view_event.h"
-#include "extensions/browser/guest_view/guest_view_manager.h"
-#include "extensions/common/guest_view/guest_view_constants.h"
-#include "extensions/common/guest_view/guest_view_messages.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 using content::WebContents;
 
 namespace content {
 struct FrameNavigateParams;
 }
 
-namespace extensions {
+namespace guest_view {
 
 namespace {
 
 using WebContentsGuestViewMap = std::map<const WebContents*, GuestViewBase*>;
 static base::LazyInstance<WebContentsGuestViewMap> webcontents_guestview_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 SetSizeParams::SetSizeParams() {
@@ skipping 99 matching lines @@
 
   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::FromBrowserContext(browser_context_)->
               GetNextInstanceID()),
-      view_instance_id_(guestview::kInstanceIDNone),
-      element_instance_id_(guestview::kInstanceIDNone),
+      view_instance_id_(kInstanceIDNone),
+      element_instance_id_(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();
@@ skipping 45 matching lines @@
       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::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_);
+  create_params.GetInteger(kParameterInstanceId, &view_instance_id_);
 
   if (CanRunInDetachedState())
     SetUpSizing(create_params);
 
   // Observe guest zoom changes.
   auto zoom_controller =
       ui_zoom::ZoomController::FromWebContents(web_contents());
   zoom_controller->AddObserver(this);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize(create_params);
 }
 
 void GuestViewBase::LoadURLWithParams(
       const content::NavigationController::LoadURLParams& load_params) {
   int guest_proxy_routing_id = host()->LoadURLWithParams(load_params);
   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
          guest_proxy_routing_id == guest_proxy_routing_id_);
   guest_proxy_routing_id_ = guest_proxy_routing_id;
 }
 
 void GuestViewBase::DispatchOnResizeEvent(const gfx::Size& old_size,
                                           const gfx::Size& new_size) {
   if (new_size == old_size)
     return;
 
   // Dispatch the onResize event.
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  args->SetInteger(guestview::kOldWidth, old_size.width());
-  args->SetInteger(guestview::kOldHeight, old_size.height());
-  args->SetInteger(guestview::kNewWidth, new_size.width());
-  args->SetInteger(guestview::kNewHeight, new_size.height());
-  DispatchEventToGuestProxy(
-      new GuestViewEvent(guestview::kEventResize, args.Pass()));
+  args->SetInteger(kOldWidth, old_size.width());
+  args->SetInteger(kOldHeight, old_size.height());
+  args->SetInteger(kNewWidth, new_size.width());
+  args->SetInteger(kNewHeight, new_size.height());
+  DispatchEventToGuestProxy(new GuestViewEvent(kEventResize, args.Pass()));
 }
 
 gfx::Size GuestViewBase::GetDefaultSize() const {
   if (is_full_page_plugin()) {
     // Full page plugins default to the size of the owner's viewport.
     return owner_web_contents()
         ->GetRenderWidgetHostView()
         ->GetVisibleViewportSize();
   } else {
-    return gfx::Size(guestview::kDefaultWidth, guestview::kDefaultHeight);
+    return gfx::Size(kDefaultWidth, kDefaultHeight);
   }
 }
 
 void GuestViewBase::SetSize(const SetSizeParams& params) {
   bool enable_auto_size =
       params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_;
   gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_;
   gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_;
 
   if (params.normal_size)
@@ skipping 124 matching lines @@
       guest_proxy_routing_id));
 
   SendQueuedEvents();
 }
 
 void GuestViewBase::DidDetach() {
   GuestViewManager::FromBrowserContext(browser_context_)->DetachGuest(this);
   StopTrackingEmbedderZoomLevel();
   owner_web_contents()->Send(new GuestViewMsg_GuestDetached(
       element_instance_id_));
-  element_instance_id_ = guestview::kInstanceIDNone;
+  element_instance_id_ = kInstanceIDNone;
 }
 
 WebContents* GuestViewBase::GetOwnerWebContents() const {
   return owner_web_contents_;
 }
 
 void GuestViewBase::GuestSizeChanged(const gfx::Size& new_size) {
   if (!auto_size_enabled_)
     return;
   GuestSizeChangedDueToAutoSize(guest_size_, new_size);
@@ skipping 34 matching lines @@
   webcontents_guestview_map.Get().erase(web_contents());
   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_);
+  attach_params_->GetInteger(kParameterInstanceId, &view_instance_id_);
 }
 
 void GuestViewBase::SetOpener(GuestViewBase* guest) {
   if (guest && guest->IsViewType(GetViewType())) {
     opener_ = guest->weak_ptr_factory_.GetWeakPtr();
     if (!attached())
       opener_lifetime_observer_.reset(new OpenerLifetimeObserver(this));
     return;
   }
   opener_ = base::WeakPtr<GuestViewBase>();
@@ skipping 256 matching lines @@
     return 1.0;
 
   return content::ZoomLevelToZoomFactor(
       ui_zoom::ZoomController::GetZoomLevelForWebContents(
           embedder_web_contents()));
 }
 
 void GuestViewBase::SetUpSizing(const base::DictionaryValue& params) {
   // Read the autosize parameters passed in from the embedder.
   bool auto_size_enabled = auto_size_enabled_;
-  params.GetBoolean(guestview::kAttributeAutoSize, &auto_size_enabled);
+  params.GetBoolean(kAttributeAutoSize, &auto_size_enabled);
 
   int max_height = max_auto_size_.height();
   int max_width = max_auto_size_.width();
-  params.GetInteger(guestview::kAttributeMaxHeight, &max_height);
-  params.GetInteger(guestview::kAttributeMaxWidth, &max_width);
+  params.GetInteger(kAttributeMaxHeight, &max_height);
+  params.GetInteger(kAttributeMaxWidth, &max_width);
 
   int min_height = min_auto_size_.height();
   int min_width = min_auto_size_.width();
-  params.GetInteger(guestview::kAttributeMinHeight, &min_height);
-  params.GetInteger(guestview::kAttributeMinWidth, &min_width);
+  params.GetInteger(kAttributeMinHeight, &min_height);
+  params.GetInteger(kAttributeMinWidth, &min_width);
 
   double element_height = 0.0;
   double element_width = 0.0;
-  params.GetDouble(guestview::kElementHeight, &element_height);
-  params.GetDouble(guestview::kElementWidth, &element_width);
+  params.GetDouble(kElementHeight, &element_height);
+  params.GetDouble(kElementWidth, &element_width);
 
   // Set the normal size to the element size so that the guestview will fit
   // the element initially if autosize is disabled.
   int normal_height = normal_size_.height();
   int normal_width = normal_size_.width();
   // If the element size was provided in logical units (versus physical), then
   // it will be converted to physical units.
   bool element_size_is_logical = false;
-  params.GetBoolean(guestview::kElementSizeIsLogical, &element_size_is_logical);
+  params.GetBoolean(kElementSizeIsLogical, &element_size_is_logical);
   if (element_size_is_logical) {
     // Convert the element size from logical pixels to physical pixels.
     normal_height = LogicalPixelsToPhysicalPixels(element_height);
     normal_width = LogicalPixelsToPhysicalPixels(element_width);
   } else {
     normal_height = lround(element_height);
     normal_width = lround(element_width);
   }
 
   SetSizeParams set_size_params;
@@ skipping 38 matching lines @@
     return;
 
   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
+}  // namespace guest_view