Move ZoomObserver, ZoomController and ZoomEventManager to components/.

components/ui/zoom/zoom_controller.cc

 // Copyright (c) 2012 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/ui/zoom/zoom_controller.h"
+#include "components/ui/zoom/zoom_controller.h"
 
-#include "chrome/browser/ui/sad_tab.h"
-#include "chrome/browser/ui/zoom/zoom_event_manager.h"
-#include "chrome/browser/ui/zoom/zoom_observer.h"
+#include "components/ui/zoom/zoom_event_manager.h"
+#include "components/ui/zoom/zoom_observer.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_type.h"
 #include "content/public/common/page_zoom.h"
-#include "extensions/common/extension.h"
-#include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 
-DEFINE_WEB_CONTENTS_USER_DATA_KEY(ZoomController);
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(ui_zoom::ZoomController);
+
+namespace ui_zoom {
 
 ZoomController::ZoomController(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       can_show_bubble_(true),
       zoom_mode_(ZOOM_MODE_DEFAULT),
       zoom_level_(1.0),
       browser_context_(web_contents->GetBrowserContext()) {
   content::HostZoomMap* host_zoom_map =
       content::HostZoomMap::GetForWebContents(web_contents);
   zoom_level_ = host_zoom_map->GetDefaultZoomLevel();
 
   zoom_subscription_ = host_zoom_map->AddZoomLevelChangedCallback(
       base::Bind(&ZoomController::OnZoomLevelChanged, base::Unretained(this)));
 
   UpdateState(std::string());
 }
 
-ZoomController::~ZoomController() {}
+ZoomController::~ZoomController() {
+}
 
 bool ZoomController::IsAtDefaultZoom() const {
   return content::ZoomValuesEqual(GetZoomLevel(), GetDefaultZoomLevel());
 }
 
-int ZoomController::GetResourceForZoomLevel() const {
-  if (IsAtDefaultZoom())
-    return IDR_ZOOM_NORMAL;
-  return GetZoomLevel() > GetDefaultZoomLevel() ? IDR_ZOOM_PLUS
-                                                : IDR_ZOOM_MINUS;
+ZoomController::RelativeZoom ZoomController::GetZoomRelativeToDefault() const {
+  double current_level = GetZoomLevel();
+  double default_level = GetDefaultZoomLevel();
+  if (content::ZoomValuesEqual(current_level, default_level))
+    return ZOOM_AT_DEFAULT_ZOOM;
+  else if (current_level > default_level)
+    return ZOOM_ABOVE_DEFAULT_ZOOM;
+  return ZOOM_BELOW_DEFAULT_ZOOM;
 }
 
 void ZoomController::AddObserver(ZoomObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ZoomController::RemoveObserver(ZoomObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 double ZoomController::GetZoomLevel() const {
-  return zoom_mode_ == ZOOM_MODE_MANUAL ?
-             zoom_level_:
-             content::HostZoomMap::GetZoomLevel(web_contents());
+  return zoom_mode_ == ZOOM_MODE_MANUAL
+             ? zoom_level_
+             : content::HostZoomMap::GetZoomLevel(web_contents());
 }
 
 int ZoomController::GetZoomPercent() const {
   double zoom_factor = content::ZoomLevelToZoomFactor(GetZoomLevel());
   // Round double for return.
   return static_cast<int>(zoom_factor * 100 + 0.5);
 }
 
 bool ZoomController::SetZoomLevel(double zoom_level) {
-  // An extension did not initiate this zoom change.
-  return SetZoomLevelByExtension(zoom_level, NULL);
+  // A client did not initiate this zoom change.
+  return SetZoomLevelByClient(zoom_level, NULL);
 }
 
-bool ZoomController::SetZoomLevelByExtension(
+bool ZoomController::SetZoomLevelByClient(
     double zoom_level,
-    const scoped_refptr<const extensions::Extension>& extension) {
+    const scoped_refptr<const ZoomRequestClient>& client) {
   content::NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
   // Cannot zoom in disabled mode. Also, don't allow changing zoom level on
   // a crashed tab, an error page or an interstitial page.
   if (zoom_mode_ == ZOOM_MODE_DISABLED ||
       !web_contents()->GetRenderViewHost()->IsRenderViewLive())
     return false;
 
-  // Store extension data so that |extension| can be attributed when the zoom
+  // Store client data so the |client| can be attributed when the zoom
   // change completes. We expect that by the time this function returns that
   // any observers that require this information will have requested it.
-  last_extension_ = extension;
+  last_client_ = client;
 
   // Do not actually rescale the page in manual mode.
   if (zoom_mode_ == ZOOM_MODE_MANUAL) {
     double old_zoom_level = zoom_level_;
     zoom_level_ = zoom_level;
 
     // TODO(wjmaclean) Do we care about filling in host/scheme here?
     content::HostZoomMap::ZoomLevelChange change;
     change.mode = content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
     change.zoom_level = zoom_level;
-    ZoomEventManager::GetForBrowserContext(browser_context_)->
-        OnZoomLevelChanged(change);
+    ZoomEventManager::GetForBrowserContext(browser_context_)
+        ->OnZoomLevelChanged(change);
 
-    ZoomChangedEventData zoom_change_data(web_contents(),
-                                          old_zoom_level,
-                                          zoom_level_,
-                                          zoom_mode_,
+    ZoomChangedEventData zoom_change_data(web_contents(), old_zoom_level,
+                                          zoom_level_, zoom_mode_,
                                           false /* can_show_bubble */);
-    FOR_EACH_OBSERVER(
-        ZoomObserver, observers_, OnZoomChanged(zoom_change_data));
+    FOR_EACH_OBSERVER(ZoomObserver, observers_,
+                      OnZoomChanged(zoom_change_data));
 
-    last_extension_ = NULL;
+    last_client_ = NULL;
     return true;
   }
 
   content::HostZoomMap* zoom_map =
       content::HostZoomMap::GetForWebContents(web_contents());
   DCHECK(zoom_map);
   DCHECK(!event_data_);
-  event_data_.reset(new ZoomChangedEventData(web_contents(),
-                                             GetZoomLevel(),
-                                             zoom_level,
-                                             zoom_mode_,
+  event_data_.reset(new ZoomChangedEventData(web_contents(), GetZoomLevel(),
+                                             zoom_level, zoom_mode_,
                                              false /* can_show_bubble */));
   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
   if (zoom_mode_ == ZOOM_MODE_ISOLATED ||
       zoom_map->UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
-    zoom_map->SetTemporaryZoomLevel(
-        render_process_id, render_view_id, zoom_level);
+    zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                    zoom_level);
   } else {
     if (!entry) {
-      last_extension_ = NULL;
+      last_client_ = NULL;
       return false;
     }
     std::string host =
         net::GetHostOrSpecFromURL(content::HostZoomMap::GetURLFromEntry(entry));
     zoom_map->SetZoomLevelForHost(host, zoom_level);
   }
 
   DCHECK(!event_data_);
-  last_extension_ = NULL;
+  last_client_ = NULL;
   return true;
 }
 
 void ZoomController::SetZoomMode(ZoomMode new_mode) {
   if (new_mode == zoom_mode_)
     return;
 
   content::HostZoomMap* zoom_map =
       content::HostZoomMap::GetForWebContents(web_contents());
   DCHECK(zoom_map);
   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
   double original_zoom_level = GetZoomLevel();
 
   DCHECK(!event_data_);
-  event_data_.reset(new ZoomChangedEventData(web_contents(),
-                                             original_zoom_level,
-                                             original_zoom_level,
-                                             new_mode,
-                                             new_mode != ZOOM_MODE_DEFAULT));
+  event_data_.reset(new ZoomChangedEventData(
+      web_contents(), original_zoom_level, original_zoom_level, new_mode,
+      new_mode != ZOOM_MODE_DEFAULT));
 
   switch (new_mode) {
     case ZOOM_MODE_DEFAULT: {
       content::NavigationEntry* entry =
           web_contents()->GetController().GetLastCommittedEntry();
 
       if (entry) {
         GURL url = content::HostZoomMap::GetURLFromEntry(entry);
         std::string host = net::GetHostOrSpecFromURL(url);
 
         if (zoom_map->HasZoomLevel(url.scheme(), host)) {
           // If there are other tabs with the same origin, then set this tab's
           // zoom level to match theirs. The temporary zoom level will be
           // cleared below, but this call will make sure this tab re-draws at
           // the correct zoom level.
           double origin_zoom_level =
               zoom_map->GetZoomLevelForHostAndScheme(url.scheme(), host);
           event_data_->new_zoom_level = origin_zoom_level;
-          zoom_map->SetTemporaryZoomLevel(
-              render_process_id, render_view_id, origin_zoom_level);
+          zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                          origin_zoom_level);
         } else {
           // The host will need a level prior to removing the temporary level.
           // We don't want the zoom level to change just because we entered
           // default mode.
           zoom_map->SetZoomLevelForHost(host, original_zoom_level);
         }
       }
       // Remove per-tab zoom data for this tab. No event callback expected.
       zoom_map->ClearTemporaryZoomLevel(render_process_id, render_view_id);
       break;
     }
     case ZOOM_MODE_ISOLATED: {
       // Unless the zoom mode was |ZOOM_MODE_DISABLED| before this call, the
       // page needs an initial isolated zoom back to the same level it was at
       // in the other mode.
       if (zoom_mode_ != ZOOM_MODE_DISABLED) {
-        zoom_map->SetTemporaryZoomLevel(
-            render_process_id, render_view_id, original_zoom_level);
+        zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                        original_zoom_level);
       } else {
         // When we don't call any HostZoomMap set functions, we send the event
         // manually.
-        FOR_EACH_OBSERVER(
-            ZoomObserver, observers_, OnZoomChanged(*event_data_));
+        FOR_EACH_OBSERVER(ZoomObserver, observers_,
+                          OnZoomChanged(*event_data_));
         event_data_.reset();
       }
       break;
     }
     case ZOOM_MODE_MANUAL: {
       // Unless the zoom mode was |ZOOM_MODE_DISABLED| before this call, the
       // page needs to be resized to the default zoom. While in manual mode,
       // the zoom level is handled independently.
       if (zoom_mode_ != ZOOM_MODE_DISABLED) {
-        zoom_map->SetTemporaryZoomLevel(
-            render_process_id, render_view_id, GetDefaultZoomLevel());
+        zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                        GetDefaultZoomLevel());
         zoom_level_ = original_zoom_level;
       } else {
         // When we don't call any HostZoomMap set functions, we send the event
         // manually.
-        FOR_EACH_OBSERVER(
-            ZoomObserver, observers_, OnZoomChanged(*event_data_));
+        FOR_EACH_OBSERVER(ZoomObserver, observers_,
+                          OnZoomChanged(*event_data_));
         event_data_.reset();
       }
       break;
     }
     case ZOOM_MODE_DISABLED: {
       // The page needs to be zoomed back to default before disabling the zoom
-      zoom_map->SetTemporaryZoomLevel(
-          render_process_id, render_view_id, GetDefaultZoomLevel());
+      zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id,
+                                      GetDefaultZoomLevel());
       break;
     }
   }
   // Any event data we've stored should have been consumed by this point.
   DCHECK(!event_data_);
 
   zoom_mode_ = new_mode;
 }
 
 void ZoomController::DidNavigateMainFrame(
@@ skipping 35 matching lines @@
   // The zoom bubble should not be shown for zoom changes where the host is
   // empty.
   bool can_show_bubble = can_show_bubble_ && !host.empty();
 
   if (event_data_) {
     // For state changes initiated within the ZoomController, information about
     // the change should be sent.
     ZoomChangedEventData zoom_change_data = *event_data_;
     event_data_.reset();
     zoom_change_data.can_show_bubble = can_show_bubble;
-    FOR_EACH_OBSERVER(
-        ZoomObserver, observers_, OnZoomChanged(zoom_change_data));
+    FOR_EACH_OBSERVER(ZoomObserver, observers_,
+                      OnZoomChanged(zoom_change_data));
   } else {
     // TODO(wjmaclean) Should we consider having HostZoomMap send both old and
     // new zoom levels here?
     double zoom_level = GetZoomLevel();
     ZoomChangedEventData zoom_change_data(
         web_contents(), zoom_level, zoom_level, zoom_mode_, can_show_bubble);
-    FOR_EACH_OBSERVER(
-        ZoomObserver, observers_, OnZoomChanged(zoom_change_data));
+    FOR_EACH_OBSERVER(ZoomObserver, observers_,
+                      OnZoomChanged(zoom_change_data));
   }
 }
+
+}  // namespace ui_zoom