Add setting to isolate zoom changes by default.

chrome/browser/ui/zoom/zoom_controller_browsertest.cc

Index: chrome/browser/ui/zoom/zoom_controller_browsertest.cc
diff --git a/chrome/browser/ui/zoom/zoom_controller_browsertest.cc b/chrome/browser/ui/zoom/zoom_controller_browsertest.cc
index d0d8ea33a8c492f3e1605ef478a76dedcdfd71b9..0937464e6876561fcb5554873d7f43b927281a0a 100644
--- a/chrome/browser/ui/zoom/zoom_controller_browsertest.cc
+++ b/chrome/browser/ui/zoom/zoom_controller_browsertest.cc
@@ -12,6 +12,7 @@
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/signin/login_ui_test_utils.h"
+#include "chrome/browser/ui/zoom/chrome_zoom_level_otr_delegate.h"
 #include "chrome/browser/ui/zoom/chrome_zoom_level_prefs.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
@@ -22,6 +23,7 @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_type.h"
 #include "content/public/test/browser_test_utils.h"
@@ -70,6 +72,15 @@ class ZoomControllerBrowserTest : public InProcessBrowserTest {
   ZoomControllerBrowserTest() {}
   ~ZoomControllerBrowserTest() override {}
 
+  void SetUpOnMainThread() override {
+    // These tests assume we are per-origin by default.
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    ZoomController* zoom_controller =
+        ZoomController::FromWebContents(web_contents);
+    ASSERT_EQ(ZoomController::ZOOM_MODE_DEFAULT, zoom_controller->zoom_mode());
+  }
+
   void TestResetOnNavigation(ZoomController::ZoomMode zoom_mode) {
     DCHECK(zoom_mode == ZoomController::ZOOM_MODE_ISOLATED ||
            zoom_mode == ZoomController::ZOOM_MODE_MANUAL);
@@ -329,3 +340,198 @@ IN_PROC_BROWSER_TEST_F(ZoomControllerBrowserTest,
   zoom_change_watcher.Wait();
 }
 #endif  // !defined(OS_CHROMEOS)
+
+
+class ZoomControllerPerTabBrowserTest : public ZoomControllerBrowserTest {
+ public:
+  void SetUpOnMainThread() override {
+    // These tests assume we are per-tab by default.
+    ChromeZoomLevelPrefs* zoom_prefs =
+        browser()->profile()->GetZoomLevelPrefs();

[Kevin McNee, 2017/02/03 23:17:20]

It looks like Profile::GetZoomLevelPrefs is to be removed. Should we just be
using the profile's default storage partition directly?

[wjmaclean, 2017/02/06 16:09:07]

Are ZoomLevelPrefs going away? (I haven't heard of this). What is the
corresponding information/state in the storage partition?

[Kevin McNee, 2017/02/06 18:26:12]

See https://cs.chromium.org/chromium/src/chrome/browser/profiles/profile.h?l=181

Since the prefs have been moved into the storage partition, this is now
essentially a convenience method equivalent to
|GetDefaultStoragePartition(profile())->GetZoomLevelDelegate()|. Is this
convenience method going to stick around or should we be using the latter?

[wjmaclean, 2017/02/06 18:48:38]

Assume it will stick around for now.

+    ASSERT_TRUE(zoom_prefs);
+    zoom_prefs->SetZoomScopeIsPerOriginPref(false);
+
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    ZoomController* zoom_controller =
+        ZoomController::FromWebContents(web_contents);
+    // Since this zoom controller was initialized before SetUpOnMainThread()
+    // was called, we need to verify that this zoom controller's mode was
+    // updated when we set the zoom scope preference.
+    ASSERT_EQ(ZoomController::ZOOM_MODE_ISOLATED, zoom_controller->zoom_mode());
+  }
+};  // ZoomControllerPerTabBrowserTest
+
+IN_PROC_BROWSER_TEST_F(ZoomControllerPerTabBrowserTest, IsolatedZoom) {
+  content::WebContents* web_contents1 =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  ZoomController* zoom_controller1 =
+      ZoomController::FromWebContents(web_contents1);
+  double old_zoom_level = zoom_controller1->GetZoomLevel();
+
+  double new_zoom_level1 = old_zoom_level + 0.5;
+  ZoomController::ZoomChangedEventData zoom_change_data1(
+      web_contents1,
+      old_zoom_level,
+      new_zoom_level1,
+      ZoomController::ZOOM_MODE_ISOLATED,
+      true);
+  ZoomChangedWatcher zoom_change_watcher1(web_contents1, zoom_change_data1);
+  zoom_controller1->SetZoomLevel(new_zoom_level1);
+  zoom_change_watcher1.Wait();
+
+  // The new tab should start with the default zoom, and not be affected by
+  // the zoom level set in the other tab.
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), GURL("about:blank"),
+      WindowOpenDisposition::NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+  content::WebContents* web_contents2 =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  ZoomController* zoom_controller2 =
+      ZoomController::FromWebContents(web_contents2);
+  EXPECT_TRUE(zoom_controller2->IsAtDefaultZoom());
+
+  double new_zoom_level2 = old_zoom_level + 1.0;
+  ZoomController::ZoomChangedEventData zoom_change_data2(
+      web_contents2,
+      old_zoom_level,
+      new_zoom_level2,
+      ZoomController::ZOOM_MODE_ISOLATED,
+      true);
+  ZoomChangedWatcher zoom_change_watcher2(web_contents2, zoom_change_data2);
+  zoom_controller2->SetZoomLevel(new_zoom_level2);
+  zoom_change_watcher2.Wait();
+
+  // Now when we zoom the second tab, the first should not be affected.
+  EXPECT_TRUE(content::ZoomValuesEqual(new_zoom_level1,
+                                       zoom_controller1->GetZoomLevel()));
+}
+
+// Since we are zooming on a per-tab basis, the navigation of a tab does not
+// reset the zoom level.
+IN_PROC_BROWSER_TEST_F(ZoomControllerPerTabBrowserTest,
+                       NavigationPreservesZoom) {
+  ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  ZoomController* zoom_controller =
+      ZoomController::FromWebContents(web_contents);
+
+  double old_zoom_level = zoom_controller->GetZoomLevel();
+  double new_zoom_level = old_zoom_level + 0.5;
+  ZoomController::ZoomChangedEventData zoom_change_data(
+      web_contents,
+      old_zoom_level,
+      new_zoom_level,
+      ZoomController::ZOOM_MODE_ISOLATED,
+      true);
+  ZoomChangedWatcher zoom_change_watcher(web_contents, zoom_change_data);
+  zoom_controller->SetZoomLevel(new_zoom_level);
+  zoom_change_watcher.Wait();
+
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUISettingsURL));
+  EXPECT_TRUE(content::ZoomValuesEqual(new_zoom_level,
+                                       zoom_controller->GetZoomLevel()));
+}
+
+// Test that duplicated tabs start with the temporary zoom level of the
+// original tab.
+IN_PROC_BROWSER_TEST_F(ZoomControllerPerTabBrowserTest,
+                       TabDuplicationPreservesZoom) {
+  TabStripModel* strip = browser()->tab_strip_model();
+  content::WebContents* web_contents1 = strip->GetActiveWebContents();
+  ZoomController* zoom_controller1 =
+      ZoomController::FromWebContents(web_contents1);
+
+  double old_zoom_level = zoom_controller1->GetZoomLevel();
+  double new_zoom_level = old_zoom_level + 0.5;
+
+  ZoomController::ZoomChangedEventData zoom_change_data1(
+      web_contents1,
+      old_zoom_level,
+      new_zoom_level,
+      ZoomController::ZOOM_MODE_ISOLATED,
+      true);
+  ZoomChangedWatcher zoom_change_watcher1(web_contents1, zoom_change_data1);
+  zoom_controller1->SetZoomLevel(new_zoom_level);
+  zoom_change_watcher1.Wait();
+
+  content::WebContents* web_contents2 = chrome::DuplicateTabAt(
+      browser(), strip->GetIndexOfWebContents(web_contents1));
+  ZoomController* zoom_controller2 =
+      ZoomController::FromWebContents(web_contents2);
+
+  EXPECT_TRUE(content::ZoomValuesEqual(new_zoom_level,
+                                       zoom_controller2->GetZoomLevel()));
+}
+
+// Test that swapping the WebContents for a tab (e.g. due to prerendering)
+// preserves the temporary zoom level.
+IN_PROC_BROWSER_TEST_F(ZoomControllerPerTabBrowserTest,
+                       TabStripReplacementPreservesZoom) {
+  TabStripModel* strip = browser()->tab_strip_model();
+  content::WebContents* web_contents1 = strip->GetActiveWebContents();
+  ZoomController* zoom_controller1 =
+      ZoomController::FromWebContents(web_contents1);
+
+  // Setup a new WebContents that will be swapped for the old one.
+  std::unique_ptr<content::WebContents> web_contents2(web_contents1->Clone());
+  ZoomController::CreateForWebContents(web_contents2.get());
+
+  double old_zoom_level = zoom_controller1->GetZoomLevel();
+  double new_zoom_level = old_zoom_level + 0.5;
+
+  ZoomController::ZoomChangedEventData zoom_change_data1(
+      web_contents1,
+      old_zoom_level,
+      new_zoom_level,
+      ZoomController::ZOOM_MODE_ISOLATED,
+      true);
+  ZoomChangedWatcher zoom_change_watcher1(web_contents1, zoom_change_data1);
+  zoom_controller1->SetZoomLevel(new_zoom_level);
+  zoom_change_watcher1.Wait();
+
+  // Verify that the temporary zoom level is set on the new WebContents.
+  ZoomController::ZoomChangedEventData zoom_change_data2(
+      web_contents2.get(),
+      new_zoom_level,
+      new_zoom_level,
+      ZoomController::ZOOM_MODE_ISOLATED,
+      false);
+  ZoomChangedWatcher zoom_change_watcher2(web_contents2.get(),
+                                          zoom_change_data2);
+  delete strip->ReplaceWebContentsAt(
+      strip->GetIndexOfWebContents(web_contents1), web_contents2.get());
+  zoom_change_watcher2.Wait();
+}
+
+// Test that an Incognito profile inherits its parent's default zoom scope and
+// that changes to the default zoom scope in the parent propogate to the child.
+IN_PROC_BROWSER_TEST_F(ZoomControllerPerTabBrowserTest,
+                       OffTheRecordProfileDefaultZoomScope) {
+  Browser* incognito_browser = CreateIncognitoBrowser();
+  content::WebContents* web_contents =
+      incognito_browser->tab_strip_model()->GetActiveWebContents();
+  ZoomController* zoom_controller =
+      ZoomController::FromWebContents(web_contents);
+  content::BrowserContext* context = web_contents->GetBrowserContext();
+  ASSERT_TRUE(context->IsOffTheRecord());
+
+  ChromeZoomLevelPrefs* parent_zoom_prefs =
+      browser()->profile()->GetZoomLevelPrefs();
+  ChromeZoomLevelOTRDelegate* child_zoom_prefs =
+      static_cast<ChromeZoomLevelOTRDelegate*>(
+          content::BrowserContext::GetDefaultStoragePartition(context)
+              ->GetZoomLevelDelegate());
+  ASSERT_TRUE(parent_zoom_prefs);
+  ASSERT_TRUE(child_zoom_prefs);
+
+  EXPECT_FALSE(child_zoom_prefs->GetZoomScopeIsPerOriginPref());
+  EXPECT_EQ(ZoomController::ZOOM_MODE_ISOLATED, zoom_controller->zoom_mode());
+
+  parent_zoom_prefs->SetZoomScopeIsPerOriginPref(true);
+
+  EXPECT_TRUE(child_zoom_prefs->GetZoomScopeIsPerOriginPref());
+  EXPECT_EQ(ZoomController::ZOOM_MODE_DEFAULT, zoom_controller->zoom_mode());
+}