Add default zoom functionality to chrome.tabs Zoom API.

chrome/browser/extensions/api/tabs/tabs_test.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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/zoom/chrome_zoom_level_prefs.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/api_test_utils.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
 
@@ skipping 622 matching lines @@
   testing::AssertionResult RunGetZoom(int tab_id, double* zoom_factor);
 
   // Runs chrome.tabs.setZoomSettings().
   bool RunSetZoomSettings(int tab_id, const char* mode, const char* scope);
 
   // Runs chrome.tabs.getZoomSettings().
   testing::AssertionResult RunGetZoomSettings(int tab_id,
                                               std::string* mode,
                                               std::string* scope);
 
+  // Runs chrome.tabs.getZoomSettings() and returns default zoom.
+  testing::AssertionResult RunGetDefaultZoom(int tab_id,
+                                             double* default_zoom_factor);
+
   // Runs chrome.tabs.setZoom(), expecting an error.
   std::string RunSetZoomExpectError(int tab_id,
                                     double zoom_factor);
 
   // Runs chrome.tabs.setZoomSettings(), expecting an error.
   std::string RunSetZoomSettingsExpectError(int tab_id,
                                             const char* mode,
                                             const char* scope);
 
   content::WebContents* OpenUrlAndWaitForLoad(const GURL& url);
 
  private:
   scoped_refptr<Extension> extension_;
 };
 
 void ExtensionTabsZoomTest::SetUpOnMainThread() {
   ExtensionTabsTest::SetUpOnMainThread();
   extension_ = test_util::CreateEmptyExtension();
 }
 
 bool ExtensionTabsZoomTest::RunSetZoom(int tab_id, double zoom_factor) {
   scoped_refptr<TabsSetZoomFunction> set_zoom_function(
       new TabsSetZoomFunction());
   set_zoom_function->set_extension(extension_.get());
   set_zoom_function->set_has_callback(true);
 
   return utils::RunFunction(
       set_zoom_function.get(),
-      base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
-      browser(),
+      base::StringPrintf("[%u, %lf]", tab_id, zoom_factor), browser(),
       extension_function_test_utils::NONE);
 }
 
 testing::AssertionResult ExtensionTabsZoomTest::RunGetZoom(
     int tab_id,
     double* zoom_factor) {
   scoped_refptr<TabsGetZoomFunction> get_zoom_function(
       new TabsGetZoomFunction());
   get_zoom_function->set_extension(extension_.get());
   get_zoom_function->set_has_callback(true);
@@ skipping 52 matching lines @@
 
   if (!get_zoom_settings_result)
     return testing::AssertionFailure() << "no result";
 
   *mode = api_test_utils::GetString(get_zoom_settings_result.get(), "mode");
   *scope = api_test_utils::GetString(get_zoom_settings_result.get(), "scope");
 
   return testing::AssertionSuccess();
 }
 
+testing::AssertionResult ExtensionTabsZoomTest::RunGetDefaultZoom(
+    int tab_id,
+    double* default_zoom_factor) {
+  DCHECK(default_zoom_factor);
+  scoped_refptr<TabsGetZoomSettingsFunction> get_zoom_settings_function(
+      new TabsGetZoomSettingsFunction());
+  get_zoom_settings_function->set_extension(extension_.get());
+  get_zoom_settings_function->set_has_callback(true);
+
+  scoped_ptr<base::DictionaryValue> get_zoom_settings_result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+          get_zoom_settings_function.get(),
+          base::StringPrintf("[%u]", tab_id),
+          browser())));
+
+  if (!get_zoom_settings_result)
+    return testing::AssertionFailure() << "no result";
+
+  if (!get_zoom_settings_result->GetDouble("default_zoom_factor",
+                                           default_zoom_factor))
+    return testing::AssertionFailure()
+           << "default zoom factor not found in result";
+
+  return testing::AssertionSuccess();
+}
+
 std::string ExtensionTabsZoomTest::RunSetZoomExpectError(int tab_id,
                                                          double zoom_factor) {
   scoped_refptr<TabsSetZoomFunction> set_zoom_function(
       new TabsSetZoomFunction());
   set_zoom_function->set_extension(extension_.get());
   set_zoom_function->set_has_callback(true);
 
   return utils::RunFunctionAndReturnError(
       set_zoom_function.get(),
       base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
@@ skipping 59 matching lines @@
   EXPECT_TRUE(RunSetZoom(tab_id, kZoomLevel));
   EXPECT_EQ(kZoomLevel,
             content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents)));
 
   // Test chrome.tabs.getZoom().
   zoom_factor = -1;
   EXPECT_TRUE(RunGetZoom(tab_id, &zoom_factor));
   EXPECT_EQ(kZoomLevel, zoom_factor);
 }
 
+IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, GetDefaultZoom) {
+  content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
+  content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
+  int tab_id = ExtensionTabUtil::GetTabId(web_contents);
+
+  const double kZoomFactorEpsilon = 0.00001;
+
+  auto zoom_controller = ui_zoom::ZoomController::FromWebContents(web_contents);

[not at google - send to devlin, 2015/04/01 20:34:07]

Using auto here makes it harder to read IMO, so just spell out the type.

[wjmaclean, 2015/04/01 21:23:24]

I thought this would save typing ui_zoom::ZoomController twice on the same line,
but no worries!

Done.

+  double default_zoom_factor = -1.0;
+  EXPECT_TRUE(RunGetDefaultZoom(tab_id, &default_zoom_factor));
+  EXPECT_NEAR(zoom_controller->GetDefaultZoomLevel(),

[not at google - send to devlin, 2015/04/01 20:34:07]

I've been told that it's better to use EXPECT_DOUBLE_EQ rather than EXPECT_NEAR.
The former figures out the epsilon automatically.

[wjmaclean, 2015/04/01 21:23:24]

I tried using that initially, but it fails with output like:

../../chrome/browser/extensions/api/tabs/tabs_test.cc:911: Failure
Value of: content::ZoomFactorToZoomLevel(default_zoom_factor)
  Actual: 0.49999999999999972
Expected: default_zoom_level + 0.5
Which is: 0.5

Given that here they differ by ~0.000000000000001/.5 = 1 part in a hundred
trillion (if I'm counting zeroes correctly), I think the other way is safer. The
Zoom API forces conversions between zoom factors and levels, which involves
log(), so we expect some non-trivial epsilon.

[not at google - send to devlin, 2015/04/01 22:26:11]

Could you make a note of that; or perhaps better, document it via a method which
does this for you. I had in mind something like

// Explain why implementing own floating point checker.
testing::AssertionResult CheckDefaultZoomLevel(
    double expected, ZoomController controller) {
  double kEpsilon = ...;
  double actual = controller->GetDefaultZoomLevel();
  return abs(expected - actual) < kEpsilon ?
      testing::AssertionSuccess() :
      testing::AssertionFailure() << // etc;
}

+              content::ZoomFactorToZoomLevel(default_zoom_factor),
+              kZoomFactorEpsilon);
+
+  // Change the default zoom level and verify GetDefaultZoom returns the
+  // correct value.
+  content::StoragePartition* partition =
+      content::BrowserContext::GetStoragePartition(
+          web_contents->GetBrowserContext(), web_contents->GetSiteInstance());
+  chrome::ChromeZoomLevelPrefs* zoom_prefs =
+      static_cast<chrome::ChromeZoomLevelPrefs*>(
+          partition->GetZoomLevelDelegate());
+
+  double default_zoom_level = zoom_controller->GetDefaultZoomLevel();
+  default_zoom_level += 0.5;

[not at google - send to devlin, 2015/04/01 20:34:07]

I'd rather not mutate this default_zoom_level variable, keep it as a constant,
and instead add/subtract 0.5 as needed.

[wjmaclean, 2015/04/01 21:23:24]

Done.

+  zoom_prefs->SetDefaultZoomLevelPref(default_zoom_level);
+  default_zoom_factor = -1.0;
+  EXPECT_TRUE(RunGetDefaultZoom(tab_id, &default_zoom_factor));
+  EXPECT_NEAR(default_zoom_level,
+              content::ZoomFactorToZoomLevel(default_zoom_factor),
+              kZoomFactorEpsilon);
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, SetToDefaultZoom) {
+  content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
+  content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
+  int tab_id = ExtensionTabUtil::GetTabId(web_contents);
+
+  const double kZoomFactorEpsilon = 0.00001;
+
+  auto zoom_controller = ui_zoom::ZoomController::FromWebContents(web_contents);
+  double default_zoom_level = zoom_controller->GetDefaultZoomLevel();
+  double new_default_zoom_level = default_zoom_level + 0.42;
+
+  content::StoragePartition* partition =
+      content::BrowserContext::GetStoragePartition(
+          web_contents->GetBrowserContext(), web_contents->GetSiteInstance());
+  chrome::ChromeZoomLevelPrefs* zoom_prefs =
+      static_cast<chrome::ChromeZoomLevelPrefs*>(
+          partition->GetZoomLevelDelegate());
+
+  zoom_prefs->SetDefaultZoomLevelPref(new_default_zoom_level);
+
+  double observed_zoom_factor = -1.0;
+  EXPECT_TRUE(RunSetZoom(tab_id, 0.0));
+  EXPECT_TRUE(RunGetZoom(tab_id, &observed_zoom_factor));
+  EXPECT_NEAR(new_default_zoom_level,
+              content::ZoomFactorToZoomLevel(observed_zoom_factor),
+              kZoomFactorEpsilon);
+}
+
 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, ZoomSettings) {
   // In this test we need two URLs that (1) represent real pages (i.e. they
   // load without causing an error page load), (2) have different domains, and
   // (3) are zoomable by the extension API (this last condition rules out
   // chrome:// urls). We achieve this by noting that about:blank meets these
   // requirements, allowing us to spin up a spawned http server on localhost to
   // get the other domain.
   net::SpawnedTestServer http_server(
       net::SpawnedTestServer::TYPE_HTTP,
       net::SpawnedTestServer::kLocalhost,
@@ skipping 134 matching lines @@
   // Test chrome.tabs.setZoom().
   error = RunSetZoomExpectError(tab_id, 3.14159);
   EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
   EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions