Move //components/ui/zoom to top-level under //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 "components/guest_view/browser/guest_view_base.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.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 "components/zoom/page_zoom.h"
+#include "components/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/browser_plugin_guest_mode.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ skipping 182 matching lines @@
 
   // Create a ZoomController to allow the guest's contents to be zoomed.
   // Do this before adding the GuestView as a WebContents Observer so that
   // the GuestView and its derived classes can re-configure the ZoomController
   // after the latter has handled WebContentsObserver events (observers are
   // notified of events in the same order they are added as observers). For
   // example, GuestViewBase may wish to put its guest into isolated zoom mode
   // in DidNavigateMainFrame, but since ZoomController always resets to default
   // zoom mode on this event, GuestViewBase would need to do so after
   // ZoomController::DidNavigateMainFrame has completed.
-  ui_zoom::ZoomController::CreateForWebContents(guest_web_contents);
+  zoom::ZoomController::CreateForWebContents(guest_web_contents);
 
   // 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::FromBrowserContext(browser_context_)->
       AddGuest(guest_instance_id_, guest_web_contents);
 
   // Populate the view instance ID if we have it on creation.
   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());
+  auto zoom_controller = 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 ||
@@ skipping 362 matching lines @@
                                        bool motion,
                                        bool exited) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->ContentsMouseEvent(
       embedder_web_contents(), location, motion, exited);
 }
 
 void GuestViewBase::ContentsZoomChange(bool zoom_in) {
-  ui_zoom::PageZoom::Zoom(
-      embedder_web_contents(),
-      zoom_in ? content::PAGE_ZOOM_IN : content::PAGE_ZOOM_OUT);
+  zoom::PageZoom::Zoom(embedder_web_contents(), zoom_in
+                                                    ? content::PAGE_ZOOM_IN
+                                                    : content::PAGE_ZOOM_OUT);
 }
 
 void GuestViewBase::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (!attached())
     return;
 
   // Send the keyboard events back to the embedder to reprocess them.
   embedder_web_contents()->GetDelegate()->
@@ skipping 79 matching lines @@
     embedder_web_contents()->GetDelegate()->FindReply(embedder_web_contents(),
                                                       request_id,
                                                       number_of_matches,
                                                       selection_rect,
                                                       active_match_ordinal,
                                                       final_update);
   }
 }
 
 void GuestViewBase::OnZoomChanged(
-    const ui_zoom::ZoomController::ZoomChangedEventData& data) {
+    const zoom::ZoomController::ZoomChangedEventData& data) {
   if (data.web_contents == embedder_web_contents()) {
     // The embedder's zoom level has changed.
     auto guest_zoom_controller =
-        ui_zoom::ZoomController::FromWebContents(web_contents());
+        zoom::ZoomController::FromWebContents(web_contents());
     if (content::ZoomValuesEqual(data.new_zoom_level,
                                  guest_zoom_controller->GetZoomLevel())) {
       return;
     }
     // When the embedder's zoom level doesn't match the guest's, then update the
     // guest's zoom level to match.
     guest_zoom_controller->SetZoomLevel(data.new_zoom_level);
     return;
   }
 
@@ skipping 42 matching lines @@
   }
   InitWithWebContents(*create_params, guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
 double GuestViewBase::GetEmbedderZoomFactor() const {
   if (!embedder_web_contents())
     return 1.0;
 
   return content::ZoomLevelToZoomFactor(
-      ui_zoom::ZoomController::GetZoomLevelForWebContents(
+      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(kAttributeAutoSize, &auto_size_enabled);
 
   int max_height = max_auto_size_.height();
   int max_width = max_auto_size_.width();
@@ skipping 33 matching lines @@
   set_size_params.max_size.reset(new gfx::Size(max_width, max_height));
   set_size_params.normal_size.reset(new gfx::Size(normal_width, normal_height));
 
   // Call SetSize to apply all the appropriate validation and clipping of
   // values.
   SetSize(set_size_params);
 }
 
 void GuestViewBase::SetGuestZoomLevelToMatchEmbedder() {
   auto embedder_zoom_controller =
-      ui_zoom::ZoomController::FromWebContents(owner_web_contents());
+      zoom::ZoomController::FromWebContents(owner_web_contents());
   if (!embedder_zoom_controller)
     return;
 
-  ui_zoom::ZoomController::FromWebContents(web_contents())
+  zoom::ZoomController::FromWebContents(web_contents())
       ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
 }
 
 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
   if (!ZoomPropagatesFromEmbedderToGuest())
     return;
 
   auto embedder_zoom_controller =
-      ui_zoom::ZoomController::FromWebContents(owner_web_contents());
+      zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   // Listen to the embedder's zoom changes.
   embedder_zoom_controller->AddObserver(this);
 
   // Set the guest's initial zoom level to be equal to the embedder's.
   SetGuestZoomLevelToMatchEmbedder();
 }
 
 void GuestViewBase::StopTrackingEmbedderZoomLevel() {
   if (!attached() || !ZoomPropagatesFromEmbedderToGuest())
     return;
 
   auto embedder_zoom_controller =
-      ui_zoom::ZoomController::FromWebContents(owner_web_contents());
+      zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   embedder_zoom_controller->RemoveObserver(this);
 }
 
 void GuestViewBase::UpdateGuestSize(const gfx::Size& new_size,
                                     bool due_to_auto_resize) {
   if (due_to_auto_resize)
     GuestSizeChangedDueToAutoSize(guest_size_, new_size);
   DispatchOnResizeEvent(guest_size_, new_size);
   guest_size_ = new_size;
 }
 
 }  // namespace guest_view