Zoom Extension API

chrome/browser/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 "base/prefs/pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
@@ skipping 10 matching lines @@
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(ZoomController);
 
 ZoomController::ZoomController(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       zoom_percent_(100),
       observer_(NULL),
       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(static_cast<void(ZoomController::*)(
+          const std::string&)>(&ZoomController::UpdateState),
+                 base::Unretained(this),
+                 std::string()));
 
   zoom_subscription_ = content::HostZoomMap::GetForBrowserContext(
       browser_context_)->AddZoomLevelChangedCallback(
           base::Bind(&ZoomController::OnZoomLevelChanged,
                      base::Unretained(this)));
 
   UpdateState(std::string());
 }
 
 ZoomController::~ZoomController() {}
 
 bool ZoomController::IsAtDefaultZoom() const {
   return content::ZoomValuesEqual(web_contents()->GetZoomLevel(),
                                   default_zoom_level_.GetValue());
 }
 
 int ZoomController::GetResourceForZoomLevel() const {
   if (IsAtDefaultZoom())
     return IDR_ZOOM_NORMAL;
   double zoom = web_contents()->GetZoomLevel();
   return zoom > default_zoom_level_.GetValue() ? IDR_ZOOM_PLUS : IDR_ZOOM_MINUS;
 }
 
+const extensions::Extension* ZoomController::last_extension() const {

[not at google - send to devlin, 2014/04/11 15:04:25]

I can't find where this function, or anything referencing "last_extension", is
used?

I was looking because it seems like an odd pattern to be holding onto something
like this.

presumably it has something to do with the UI changes you were making? in which
case you should at least pull that into that separate CL; but I would hope that
you can factor this such that you don't need last_extension (e.g. the UI code
holds onto it itself if it needs).

[paulmeyer, 2014/04/11 19:09:49]

This is something that is going to change because of the content changes
anyways, so I won't worry about it now.

On 2014/04/11 15:04:25, kalman wrote:

+  return last_extension_.get();
+}
+
+bool ZoomController::SetZoomLevelByExtension(
+    double zoom_level,
+    scoped_refptr<const extensions::Extension> extension,
+    const base::Callback<void(void)>& callback) {
+  if (web_contents()->GetZoomMode() == content::kZoomModeDisabled)
+    return false;
+
+  // Call WebContents::SetZoomLevel() with a wrapper callback that calls both
+  // ZoomController::ZoomCallback and the passed-in |callback|.
+  const base::Callback<void(void)>& wrapper_callback =
+      base::Bind(&ZoomController::ZoomCallback, base::Unretained(this),
+                 extension, callback);
+  web_contents()->SetZoomLevel(zoom_level, wrapper_callback);
+  return true;
+}
+
 void ZoomController::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   // If the main frame's content has changed, the new page may have a different
   // zoom level from the old one.
   UpdateState(std::string());
 }
 
 void ZoomController::OnZoomLevelChanged(
     const content::HostZoomMap::ZoomLevelChange& change) {
-  UpdateState(change.host);
+  UpdateState(change.host,
+              change.mode == content::HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM);
 }
 
 void ZoomController::UpdateState(const std::string& host) {
+  UpdateState(host, false);
+}
+
+void ZoomController::UpdateState(const std::string& host,
+                                 bool is_temporary_zoom) {
+  // Update |last_extension_|.
+  last_extension_ = pending_extension_;
+  pending_extension_ = NULL;
+
   // If |host| is empty, all observers should be updated.
   if (!host.empty()) {
     // Use the navigation entry's URL instead of the WebContents' so virtual
     // URLs work (e.g. chrome://settings). http://crbug.com/153950
     content::NavigationEntry* entry =
         web_contents()->GetController().GetLastCommittedEntry();
     if (!entry ||
         host != net::GetHostOrSpecFromURL(entry->GetURL())) {
       return;
     }
   }
-
   bool dummy;
   zoom_percent_ = web_contents()->GetZoomPercent(&dummy, &dummy);
 
-  if (observer_)
-    observer_->OnZoomChanged(web_contents(), !host.empty());
+  if (observer_) {
+    // 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 =
+        web_contents()->GetZoomMode() != content::kZoomModeDefault ||
+        (!host.empty() && !is_temporary_zoom);
+    observer_->OnZoomChanged(web_contents(), can_show_bubble);
+  }
+
+  last_extension_ = NULL;
 }
+
+void ZoomController::ZoomCallback(
+    scoped_refptr<const extensions::Extension> extension,
+    const base::Callback<void(void)>& callback) {
+  pending_extension_ = extension;
+  callback.Run();
+}