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..cd54d363b323fe163bed0bd15225a86730704690 100644
--- a/chrome/browser/ui/zoom/zoom_controller.cc
+++ b/chrome/browser/ui/zoom/zoom_controller.cc
@@ -8,14 +8,18 @@
 #include "chrome/browser/chrome_notification_types.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,15 +27,16 @@ 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),
       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(
@@ -44,16 +49,159 @@ ZoomController::ZoomController(content::WebContents* web_contents)
 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;
+}
+
+double ZoomController::GetZoomLevel() const {
+  if (zoom_mode_ == kZoomModeManual)

[Devlin, 2014/06/19 21:15:30]

nit: Ternary if, please.

[wjmaclean, 2014/06/20 22:01:33]

Done.

+    return zoom_level_;
+  else
+    return 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) {
+  scoped_refptr<const extensions::Extension> null_extension_pointer;
+  // An extension did not initiate this zoom change.
+  return SetZoomLevelByExtension(zoom_level, null_extension_pointer);

[Devlin, 2014/06/19 21:15:29]

nit: You can just do
return SetZoomLevelByExtension(zoom_level, scoped_refptr<const
extensions::Extension>()), right?  I think that'll make it just as clear that
it's a null ptr. :)

[wjmaclean, 2014/06/20 22:01:33]

Done.

+}
+
+bool ZoomController::SetZoomLevelByExtension(
+    double zoom_level,
+    scoped_refptr<const extensions::Extension> extension) {
+  // Cannot zoom in disabled mode.
+  if (zoom_mode_ == kZoomModeDisabled)
+    return false;
+
+  if (zoom_mode_ == kZoomModeManual) {

[Devlin, 2014/06/19 21:15:30]

Do we not care about the extension in manual mode?

[wjmaclean, 2014/06/20 22:01:34]

It's probably true that consumers of OnZoomChanged events should be notified
here, and they may in turn query the zoom controller with regards to the
extension information. I've modified the code to reflect this.

+    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(web_contents()->GetBrowserContext())
+        ->OnZoomLevelChanged(change);
+
+    for (size_t i = 0; i < observers_.size(); ++i)

[Devlin, 2014/06/19 21:15:30]

From observer_list:
FOR_EACH_OBSERVER(Observer,
                  observers_,
                  OnZoomChangeInitiated(web_contents(), old_zoom_level,
zoom_level, zoom_mode_));

[wjmaclean, 2014/06/20 22:01:34]

Done.

+      observers_[i]->OnZoomChangeInitiated(
+          web_contents(), old_zoom_level, zoom_level, zoom_mode_);
+
+    return true;
+  }
+
+  // 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;
+
+  // Do not actually rescale the page in manual mode.
+  content::HostZoomMap* zoom_map = content::HostZoomMap::GetForBrowserContext(
+      web_contents()->GetBrowserContext());
+  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 (size_t i = 0; i < observers_.size(); ++i)
+    observers_[i]->OnZoomChangeInitiated(

[Devlin, 2014/06/19 21:15:29]

Same FOR_EACH_OBSERVER

[wjmaclean, 2014/06/20 22:01:33]

Done.

+        web_contents(), old_zoom_level, zoom_level, zoom_mode_);
+  last_extension_ = NULL;

[Devlin, 2014/06/19 21:15:29]

To me, it seems that if we only have last_extension() valid for the observer
notification, we should just send it out as part of the observe function.  That
way, no one thinks that last_extension() will be valid at any other time.

[wjmaclean, 2014/06/20 22:01:33]

The only consumer of this information at present is the zoom_bubble_view, and it
gets notified from UpdateState, so we still need to temporarily store the
last_extension information via SetZoomLevelByExtension().

Given that there may be other consumers of the observe messages that have no
interest in the extension, and perhaps shouldn't even know about it, I'm not
sure if we should send it or not.

When last_extension() is not valid, it returns NULL, so I'm not sure if this is
really a potential source of confusion.

[Devlin, 2014/06/23 22:56:07]

I'm confused.  It looks like last_extension_ is being set to NULL in this
function after the observers are notified.  If the only consumer is notified
from UpdateState(), how will last_extension() ever be non-null?  (I'm sure I
must be missing something, but I can't figure out what it is...)

[wjmaclean, 2014/06/24 15:38:16]

Update state gets called from the observer notifications sent out by
HostZoomMap, so SetZoomLevelByExtension() is still on the stack, and
last_extension_ is still valid.

I've made the assumption here, based on observation and reading the code, that
these callbacks are all running synchronously.

+
+  return true;
+}
+
+void ZoomController::SetZoomMode(ZoomMode new_mode) {
+  if (new_mode == zoom_mode_)
+    return;
+
+  content::HostZoomMap* zoom_map = content::HostZoomMap::GetForBrowserContext(
+      web_contents()->GetBrowserContext());
+  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 +214,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 +237,11 @@ 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 (size_t i = 0; i < observers_.size(); ++i)

[Devlin, 2014/06/19 21:15:29]

FOR_EACH_OBSERVER

[wjmaclean, 2014/06/20 22:01:34]

Done.

+    observers_[i]->OnZoomChanged(web_contents(), can_show_bubble);
 }