Zoom Extension API (chrome)

chrome/browser/ui/zoom/zoom_controller.cc

Index: chrome/browser/ui/zoom/zoom_controller.cc
diff --git a/chrome/browser/ui/zoom/zoom_controller.cc b/chrome/browser/ui/zoom/zoom_controller.cc
index 701c0dd24ad34d1fe66524ff1602021d9486933a..7bb76568e7db57e071f3d154e162d0c93069588d 100644
--- a/chrome/browser/ui/zoom/zoom_controller.cc
+++ b/chrome/browser/ui/zoom/zoom_controller.cc
@@ -6,16 +6,22 @@
 
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/extensions/api/tabs/tabs_event_router.h"
+#include "chrome/browser/extensions/api/tabs/tabs_windows_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/zoom/zoom_event_manager.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.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_zoom.h"
+#include "extensions/common/extension.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 
@@ -23,37 +29,200 @@ DEFINE_WEB_CONTENTS_USER_DATA_KEY(ZoomController);
 
 ZoomController::ZoomController(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
-      zoom_percent_(100),
-      observer_(NULL),
+      zoom_mode_(kZoomModeDefault),

[sky, 2014/06/24 16:23:42]

Can you initialize zoom_level_ too (I realize you do on 41 already, but better
to do explicitly here in case code following changes).

[wjmaclean, 2014/06/24 18:04:07]

Sure!

       browser_context_(web_contents->GetBrowserContext()) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  default_zoom_level_.Init(prefs::kDefaultZoomLevel, profile->GetPrefs(),
-                           base::Bind(&ZoomController::UpdateState,
-                                      base::Unretained(this),
-                                      std::string()));
+  default_zoom_level_.Init(
+      prefs::kDefaultZoomLevel,
+      profile->GetPrefs(),
+      base::Bind(
+          &ZoomController::UpdateState, base::Unretained(this), std::string()));
+  zoom_level_ = default_zoom_level_.GetValue();
 
   zoom_subscription_ = content::HostZoomMap::GetForBrowserContext(
       browser_context_)->AddZoomLevelChangedCallback(
           base::Bind(&ZoomController::OnZoomLevelChanged,
                      base::Unretained(this)));
 
+  AddObserver(

[sky, 2014/06/24 16:23:42]

Is this the common pattern for extension related stuff? I would expect the
TabsWindowAPI to manage who and when it wants to observer rather than other
places. In other words, I would have expected this call to exist in
TabsWindowsAPI and not here.

[wjmaclean, 2014/06/24 18:04:07]

I'm new to extension work, so I can't properly answer if this is common usage or
not. The reason I chose to put it here is that there are multiple creation
points for ZoomControllers, not all extension related, and this seemed like the
right place to ensure that the tabs event router was connected.

[sky, 2014/06/25 16:02:39]

Please get a reviewer of the extension side of things to review this. I think
the registration belongs in the extension side. See TabsEventRouter how it adds
itself as an observer when appropriate.

[wjmaclean, 2014/06/25 17:21:30]

Ok, moved observer registration to TabsEventRouter.

+      extensions::TabsWindowsAPI::Get(browser_context_)->tabs_event_router());
+
   UpdateState(std::string());
 }
 
 ZoomController::~ZoomController() {}
 
 bool ZoomController::IsAtDefaultZoom() const {
-  return content::ZoomValuesEqual(
-      content::HostZoomMap::GetZoomLevel(web_contents()),
-      default_zoom_level_.GetValue());
+  return content::ZoomValuesEqual(GetZoomLevel(),
+                                  default_zoom_level_.GetValue());
 }
 
 int ZoomController::GetResourceForZoomLevel() const {
   if (IsAtDefaultZoom())
     return IDR_ZOOM_NORMAL;
-  double zoom = content::HostZoomMap::GetZoomLevel(web_contents());
-  return zoom > default_zoom_level_.GetValue() ? IDR_ZOOM_PLUS : IDR_ZOOM_MINUS;
+  return GetZoomLevel() > default_zoom_level_.GetValue() ? IDR_ZOOM_PLUS
+                                                         : IDR_ZOOM_MINUS;
+}
+
+void ZoomController::AddObserver(ZoomObserver* observer) {
+    observers_.AddObserver(observer);

[sky, 2014/06/24 16:23:41]

nit: spacing (same on 73).

[wjmaclean, 2014/06/24 18:04:07]

Done.

+}
+
+void ZoomController::RemoveObserver(ZoomObserver* observer) {
+    observers_.RemoveObserver(observer);
+}
+
+double ZoomController::GetZoomLevel() const {
+  return zoom_mode_ == kZoomModeManual
+             ? zoom_level_
+             : content::HostZoomMap::GetZoomLevel(web_contents());
+}
+
+int ZoomController::GetZoomPercent() const {
+  double zoom_factor = content::ZoomLevelToZoomFactor(GetZoomLevel());
+  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,
+                                 scoped_refptr<const extensions::Extension>());
+}
+
+bool ZoomController::SetZoomLevelByExtension(
+    double zoom_level,
+    scoped_refptr<const extensions::Extension> extension) {
+  // Cannot zoom in disabled mode.
+  if (zoom_mode_ == kZoomModeDisabled)
+    return false;
+
+  // Store extension data so that |extension| 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;
+
+  if (zoom_mode_ == kZoomModeManual) {
+    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);
+
+    FOR_EACH_OBSERVER(
+        ZoomObserver,
+        observers_,
+        OnZoomChanged(web_contents(), true /* can_show_bubble */));
+    FOR_EACH_OBSERVER(
+        ZoomObserver,
+        observers_,
+        OnZoomChangeInitiated(
+            web_contents(), old_zoom_level, zoom_level, zoom_mode_));
+
+    last_extension_ = NULL;
+    return true;
+  }
+
+  // Do not actually rescale the page in manual mode.
+  content::HostZoomMap* zoom_map =
+      content::HostZoomMap::GetForBrowserContext(browser_context_);
+  DCHECK(zoom_map);
+  double old_zoom_level = GetZoomLevel();
+  int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
+  int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
+  if (zoom_mode_ == kZoomModeIsolated ||
+      zoom_map->UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
+    zoom_map->SetTemporaryZoomLevel(
+        render_process_id, render_view_id, zoom_level);
+  } else {
+    content::NavigationEntry* entry =
+        web_contents()->GetController().GetLastCommittedEntry();
+    // We allow empty |host| values for data urls.
+    std::string host =
+        net::GetHostOrSpecFromURL(entry ? entry->GetURL() : GURL::EmptyGURL());
+    zoom_map->SetZoomLevelForHost(host, zoom_level);
+  }
+  FOR_EACH_OBSERVER(
+      ZoomObserver,
+      observers_,
+      OnZoomChangeInitiated(
+          web_contents(), old_zoom_level, zoom_level, zoom_mode_));
+
+  last_extension_ = NULL;
+  return true;
+}
+
+void ZoomController::SetZoomMode(ZoomMode new_mode) {
+  if (new_mode == zoom_mode_)
+    return;
+
+  content::HostZoomMap* zoom_map =
+      content::HostZoomMap::GetForBrowserContext(browser_context_);
+  DCHECK(zoom_map);
+  int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
+  int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
+  double original_zoom_level = GetZoomLevel();
+
+  switch (new_mode) {
+    case kZoomModeDefault: {
+      content::NavigationEntry* entry =
+          web_contents()->GetController().GetLastCommittedEntry();
+      GURL url;
+      if (entry)
+        url = entry->GetURL();
+      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);
+        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.
+      zoom_map->ClearTemporaryZoomLevel(render_process_id, render_view_id);
+      break;
+    }
+    case kZoomModeIsolated: {
+      // Unless the zoom mode was |kZoomModeDisabled| 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_ != kZoomModeDisabled) {
+        zoom_map->SetTemporaryZoomLevel(
+            render_process_id, render_view_id, original_zoom_level);
+      }
+      break;
+    }
+    case kZoomModeManual: {
+      // Unless the zoom mode was |kZoomModeDisabled| before this call, the page
+      // needs to be resized to the default zoom before calling SetZoomLevel()
+      // so that the page can be resized manually to the same zoom as before.
+      if (zoom_mode_ != kZoomModeDisabled) {
+        zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id, 0);
+        zoom_level_ = original_zoom_level;
+      }
+      break;
+    }
+    case kZoomModeDisabled: {
+      // The page needs to be zoomed back to default before disabling the zoom
+      zoom_map->SetTemporaryZoomLevel(render_process_id, render_view_id, 0);
+      break;
+    }
+  }
+
+  zoom_mode_ = new_mode;
 }
 
 void ZoomController::DidNavigateMainFrame(
@@ -66,10 +235,17 @@ void ZoomController::DidNavigateMainFrame(
 
 void ZoomController::OnZoomLevelChanged(
     const content::HostZoomMap::ZoomLevelChange& change) {
-  UpdateState(change.host);
+  UpdateStateIncludingTemporary(
+      change.host,
+      change.mode == content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM);
 }
 
 void ZoomController::UpdateState(const std::string& host) {
+  UpdateStateIncludingTemporary(host, false);
+}
+
+void ZoomController::UpdateStateIncludingTemporary(const std::string& host,
+                                                   bool is_temporary_zoom) {
   // If |host| is empty, all observers should be updated.
   if (!host.empty()) {
     // Use the navigation entry's URL instead of the WebContents' so virtual
@@ -82,9 +258,12 @@ void ZoomController::UpdateState(const std::string& host) {
     }
   }
 
-  bool dummy;
-  zoom_percent_ = web_contents()->GetZoomPercent(&dummy, &dummy);
-
-  if (observer_)
-    observer_->OnZoomChanged(web_contents(), !host.empty());
+  // The zoom bubble can be shown for all normal, per-origin zoom changes
+  // (where the host will not be empty and the zoom is not temporary), or any
+  // special zoom changes (where the zoom mode will not be "default").
+  bool can_show_bubble =
+      zoom_mode_ != kZoomModeDefault || (!host.empty() && !is_temporary_zoom);
+  FOR_EACH_OBSERVER(ZoomObserver,
+                    observers_,
+                    OnZoomChanged(web_contents(), can_show_bubble));
 }