Move ZoomObserver, ZoomController and ZoomEventManager to components/.

extensions/browser/ui/zoom/zoom_controller.cc

Index: extensions/browser/ui/zoom/zoom_controller.cc
diff --git a/chrome/browser/ui/zoom/zoom_controller.cc b/extensions/browser/ui/zoom/zoom_controller.cc
similarity index 77%
rename from chrome/browser/ui/zoom/zoom_controller.cc
rename to extensions/browser/ui/zoom/zoom_controller.cc
index 1918ce53e484e81b0eb3aca7b1fe4694d6ba273c..f098878ce57a3c855cf01eae944f90497ca6623c 100644
--- a/chrome/browser/ui/zoom/zoom_controller.cc
+++ b/extensions/browser/ui/zoom/zoom_controller.cc
@@ -2,11 +2,8 @@
 // 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 "extensions/browser/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 "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
@@ -15,11 +12,14 @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_type.h"
 #include "content/public/common/page_zoom.h"
+#include "extensions/browser/ui/zoom/zoom_event_manager.h"
+#include "extensions/browser/ui/zoom/zoom_observer.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(extensions::ZoomController);
+
+namespace extensions {
 
 ZoomController::ZoomController(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
@@ -37,17 +37,21 @@ ZoomController::ZoomController(content::WebContents* web_contents)
   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) {
@@ -59,9 +63,9 @@ void ZoomController::RemoveObserver(ZoomObserver* 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 {
@@ -100,16 +104,14 @@ bool ZoomController::SetZoomLevelByExtension(
     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;
     return true;
@@ -119,17 +121,15 @@ bool ZoomController::SetZoomLevelByExtension(
       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;
@@ -157,11 +157,9 @@ void ZoomController::SetZoomMode(ZoomMode new_mode) {
   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: {
@@ -180,8 +178,8 @@ void ZoomController::SetZoomMode(ZoomMode new_mode) {
           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
@@ -198,13 +196,13 @@ void ZoomController::SetZoomMode(ZoomMode new_mode) {
       // 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;
@@ -214,22 +212,22 @@ void ZoomController::SetZoomMode(ZoomMode new_mode) {
       // 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;
     }
   }
@@ -285,15 +283,17 @@ void ZoomController::UpdateState(const std::string& host) {
     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 extensions