Add default zoom functionality to chrome.tabs Zoom API.

chrome/browser/extensions/api/tabs/tabs_test.cc

Index: chrome/browser/extensions/api/tabs/tabs_test.cc
diff --git a/chrome/browser/extensions/api/tabs/tabs_test.cc b/chrome/browser/extensions/api/tabs/tabs_test.cc
index 38309a6a13404ec1b909ac5565e8a24fb4b30bcc..abbb5f9fd0ac39098ba60c21b1c4f327eeb15e37 100644
--- a/chrome/browser/extensions/api/tabs/tabs_test.cc
+++ b/chrome/browser/extensions/api/tabs/tabs_test.cc
@@ -22,8 +22,11 @@
 #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"
@@ -666,6 +669,10 @@ class ExtensionTabsZoomTest : public ExtensionTabsTest {
                                               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);
@@ -694,8 +701,7 @@ bool ExtensionTabsZoomTest::RunSetZoom(int tab_id, double zoom_factor) {
 
   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);
 }
 
@@ -768,6 +774,32 @@ testing::AssertionResult ExtensionTabsZoomTest::RunGetZoomSettings(
   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(
@@ -847,6 +879,67 @@ IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, SetAndGetZoom) {
   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