Zoom Extension API (chrome)

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/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/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "ui/gfx/rect.h"
 
 namespace extensions {
 
 namespace keys = tabs_constants;
 namespace utils = extension_function_test_utils;
 
 namespace {
 
@@ skipping 549 matching lines @@
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, duplicate_result->GetType());
   // Duplicate tab id should be different from the original tab id.
   EXPECT_NE(tab_id, duplicate_tab_id);
   EXPECT_EQ(window_id, duplicate_tab_window_id);
   EXPECT_EQ(tab_index + 1, duplicate_tab_index);
   // The test empty extension has no permissions, therefore |duplicate_result|
   // should not contain url, title, and faviconUrl in the function result.
   EXPECT_FALSE(utils::HasPrivacySensitiveFields(duplicate_result.get()));
 }
 
+// Tester class for the tabs.zoom* api functions.
+class ExtensionTabsZoomTest : public ExtensionTabsTest {
+ public:
+  virtual void SetUpOnMainThread() OVERRIDE;
+
+  // Runs chrome.tabs.setZoom().
+  bool RunSetZoom(int tab_id, double zoom_factor);
+
+  // Runs chrome.tabs.getZoom().
+  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.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::OpenURLParams GetOpenParams(const char* url) const;
+  content::WebContents* OpenUrlAndWaitForLoad(const GURL& url);
+
+ private:
+  scoped_refptr<Extension> extension_;
+};
+
+void ExtensionTabsZoomTest::SetUpOnMainThread() {
+  ExtensionTabsTest::SetUpOnMainThread();
+  extension_ = utils::CreateEmptyExtension();
+}
+
+bool ExtensionTabsZoomTest::RunSetZoom(int tab_id, double zoom_factor) {
+  scoped_refptr<TabsSetZoomFunction> set_zoom_function(
+      new TabsSetZoomFunction());
+  set_zoom_function->set_extension(extension_);
+  set_zoom_function->set_has_callback(true);
+
+  return utils::RunFunction(
+      set_zoom_function.get(),
+      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_zoom_function->set_has_callback(true);
+
+  scoped_ptr<base::Value> get_zoom_result(
+      utils::RunFunctionAndReturnSingleResult(
+          get_zoom_function.get(),
+          base::StringPrintf("[%u]", tab_id),
+          browser()));
+
+  if (!get_zoom_result.get())
+    return testing::AssertionFailure() << "no result";
+  if (!get_zoom_result->GetAsDouble(zoom_factor))
+    return testing::AssertionFailure() << "result was not a double";
+
+  return testing::AssertionSuccess();
+}
+
+bool ExtensionTabsZoomTest::RunSetZoomSettings(int tab_id,
+                                               const char* mode,
+                                               const char* scope) {
+  scoped_refptr<TabsSetZoomSettingsFunction> set_zoom_settings_function(
+      new TabsSetZoomSettingsFunction());
+  set_zoom_settings_function->set_extension(extension_);
+
+  std::string args;
+  if (scope) {
+    args = base::StringPrintf("[%u, {\"mode\": \"%s\", \"scope\": \"%s\"}]",
+                              tab_id, mode, scope);
+  } else {
+    args = base::StringPrintf("[%u, {\"mode\": \"%s\"}]", tab_id, mode);
+  }
+
+  return utils::RunFunction(set_zoom_settings_function.get(),
+                            args,
+                            browser(),
+                            extension_function_test_utils::NONE);
+}
+
+testing::AssertionResult ExtensionTabsZoomTest::RunGetZoomSettings(
+    int tab_id,
+    std::string* mode,
+    std::string* scope) {
+  DCHECK(mode);
+  DCHECK(scope);
+  scoped_refptr<TabsGetZoomSettingsFunction> get_zoom_settings_function(
+      new TabsGetZoomSettingsFunction());
+  get_zoom_settings_function->set_extension(extension_);
+  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.get())
+    return testing::AssertionFailure() << "no result";
+
+  *mode = utils::GetString(get_zoom_settings_result.get(), "mode");
+  *scope = utils::GetString(get_zoom_settings_result.get(), "scope");
+
+  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_);
+  set_zoom_function->set_has_callback(true);
+
+  return utils::RunFunctionAndReturnError(
+      set_zoom_function.get(),
+      base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
+      browser());
+}
+
+std::string ExtensionTabsZoomTest::RunSetZoomSettingsExpectError(
+    int tab_id,
+    const char* mode,
+    const char* scope) {
+  scoped_refptr<TabsSetZoomSettingsFunction> set_zoom_settings_function(
+      new TabsSetZoomSettingsFunction());
+  set_zoom_settings_function->set_extension(extension_);
+
+  return utils::RunFunctionAndReturnError(set_zoom_settings_function.get(),
+                                          base::StringPrintf(
+                                              "[%u, {\"mode\": \"%s\", "
+                                              "\"scope\": \"%s\"}]",
+                                              tab_id,
+                                              mode,
+                                              scope),
+                                          browser());
+}
+
+content::WebContents* ExtensionTabsZoomTest::OpenUrlAndWaitForLoad(
+    const GURL& url) {
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(),
+      url,
+      NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+  return  browser()->tab_strip_model()->GetActiveWebContents();
+}
+
+content::OpenURLParams ExtensionTabsZoomTest::GetOpenParams(

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

nit: this could actually go in the anonymous namespace

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

Done.

+    const char* url) const {
+  return content::OpenURLParams(GURL(url),
+                                content::Referrer(),
+                                NEW_FOREGROUND_TAB,
+                                content::PAGE_TRANSITION_LINK,
+                                false);
+}
+
+namespace {
+double GetZoomLevel(const content::WebContents* web_contents) {
+  return ZoomController::FromWebContents(web_contents)->GetZoomLevel();
+}
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, SetAndGetZoom) {
+  const char kNewTestTabArgs[] = "about:blank";

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

nit: turns out we actually have a kAboutBlankURL in url/url_constants.h that
should be used.

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

Done.

+  content::OpenURLParams params(GetOpenParams(kNewTestTabArgs));
+  content::WebContents* web_contents = browser()->OpenURL(params);

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

Sorry for not bringing this up sooner, but it just occurred to me that this
should probably be using ui_test_utils::NavigateToURL(), which blocks for the
navigation (and is actually sometimes necessary for the urls to be valid).

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

Done. I assume it's OK if I use OpenUrlAndWaitForLoad()? This gives me back a
WebContents* directly and so is convenient.

+  int tab_id = ExtensionTabUtil::GetTabId(web_contents);
+
+  // Test default values before we set anything.
+  double zoom_factor = -1;
+  EXPECT_TRUE(RunGetZoom(tab_id, &zoom_factor));
+  EXPECT_EQ(1.0, zoom_factor);
+
+  // Test chrome.tabs.setZoom().
+  const double kZoomLevel = 0.8;
+  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, ZoomSettings) {
+  const char kNewTestTabArgsA[] = "data:text/html,A";
+  const char kNewTestTabArgsB[] = "data:text/html,B";
+
+  content::OpenURLParams params_A(GetOpenParams(kNewTestTabArgsA));
+  content::OpenURLParams params_B(GetOpenParams(kNewTestTabArgsB));
+
+  // Tabs A1 and A2 are navigated to the same origin, while B is navigated
+  // to a different one.
+  content::WebContents* web_contents_A1 = OpenUrlAndWaitForLoad(params_A.url);
+  content::WebContents* web_contents_A2 = OpenUrlAndWaitForLoad(params_A.url);
+  content::WebContents* web_contents_B = OpenUrlAndWaitForLoad(params_B.url);
+
+  int tab_id_A1 = ExtensionTabUtil::GetTabId(web_contents_A1);
+  int tab_id_A2 = ExtensionTabUtil::GetTabId(web_contents_A2);
+  int tab_id_B = ExtensionTabUtil::GetTabId(web_contents_B);
+
+  ASSERT_FLOAT_EQ(
+      1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
+  ASSERT_FLOAT_EQ(
+      1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
+  ASSERT_FLOAT_EQ(
+      1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_B)));
+
+  // Test per-origin automatic zoom settings.
+  EXPECT_TRUE(RunSetZoom(tab_id_B, 1.f));
+  EXPECT_TRUE(RunSetZoom(tab_id_A2, 1.1f));
+  EXPECT_FLOAT_EQ(
+      1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
+  EXPECT_FLOAT_EQ(
+      1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
+  EXPECT_FLOAT_EQ(1.f,
+                  content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_B)));
+
+  // Test per-tab automatic zoom settings.
+  EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "automatic", "per-tab"));
+  EXPECT_TRUE(RunSetZoom(tab_id_A1, 1.2f));
+  EXPECT_FLOAT_EQ(
+      1.2f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
+  EXPECT_FLOAT_EQ(
+      1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
+
+  // Test 'manual' mode.
+  EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "manual", NULL));
+  EXPECT_TRUE(RunSetZoom(tab_id_A1, 1.3f));
+  EXPECT_FLOAT_EQ(
+      1.3f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
+  EXPECT_FLOAT_EQ(
+      1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
+
+  // Test 'disabled' mode, which will reset A1's zoom to 1.f.
+  EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "disabled", NULL));
+  std::string error = RunSetZoomExpectError(tab_id_A1, 1.4f);
+  EXPECT_TRUE(MatchPattern(error, keys::kCannotZoomDisabledTabError));
+  EXPECT_FLOAT_EQ(
+      1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
+  // We should still be able to zoom A2 though.
+  EXPECT_TRUE(RunSetZoom(tab_id_A2, 1.4f));
+  EXPECT_FLOAT_EQ(
+      1.4f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, GetZoomSettings) {
+  const char kNewTestTabArgs[] = "about:blank";
+  content::OpenURLParams params(GetOpenParams(kNewTestTabArgs));
+  content::WebContents* web_contents = browser()->OpenURL(params);
+  int tab_id = ExtensionTabUtil::GetTabId(web_contents);
+
+  std::string mode;
+  std::string scope;
+
+  EXPECT_TRUE(RunGetZoomSettings(tab_id, &mode, &scope));
+  EXPECT_EQ("automatic", mode);
+  EXPECT_EQ("per-origin", scope);
+
+  EXPECT_TRUE(RunSetZoomSettings(tab_id, "automatic", "per-tab"));
+  EXPECT_TRUE(RunGetZoomSettings(tab_id, &mode, &scope));
+
+  EXPECT_EQ("automatic", mode);
+  EXPECT_EQ("per-tab", scope);
+
+  std::string error =
+      RunSetZoomSettingsExpectError(tab_id, "manual", "per-origin");
+  EXPECT_TRUE(MatchPattern(error,
+                           keys::kPerOriginOnlyInAutomaticError));
+  error =
+      RunSetZoomSettingsExpectError(tab_id, "disabled", "per-origin");
+  EXPECT_TRUE(MatchPattern(error,
+                           keys::kPerOriginOnlyInAutomaticError));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, CannotZoomInvalidTab) {
+  {
+    const char kNewTestTabArgs[] = "about:blank";
+    content::OpenURLParams params(GetOpenParams(kNewTestTabArgs));
+    content::WebContents* web_contents = browser()->OpenURL(params);
+    int tab_id = ExtensionTabUtil::GetTabId(web_contents);
+
+    int bogus_id = tab_id + 100;
+    std::string error = RunSetZoomExpectError(bogus_id, 3.14159);
+    EXPECT_TRUE(MatchPattern(error, keys::kTabNotFoundError));
+
+    error = RunSetZoomSettingsExpectError(bogus_id, "manual", "per-tab");
+    EXPECT_TRUE(MatchPattern(error, keys::kTabNotFoundError));
+  }

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

nit: If there's no reason for the extra scoping, go ahead and remove it.

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

Done.

+  {
+    const char kNewTestTabArgs[] = "chrome://version";
+    content::OpenURLParams params(GetOpenParams(kNewTestTabArgs));
+    content::WebContents* web_contents = browser()->OpenURL(params);
+    int tab_id = ExtensionTabUtil::GetTabId(web_contents);
+
+    // Test chrome.tabs.setZoom().
+    std::string error = RunSetZoomExpectError(tab_id, 3.14159);
+    fprintf(stderr, "wjm: error=[%s]\n", error.c_str());

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

Remove

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

Done.

+    EXPECT_TRUE(MatchPattern(error, keys::kCannotZoomChromePagesError));
+
+    // chrome.tabs.setZoomSettings().
+    error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
+    EXPECT_TRUE(MatchPattern(error,
+                             keys::kCannotChangeChromePageZoomSettingsError));
+  }
+}
+
 }  // namespace extensions