Add setting to isolate zoom changes by default.

chrome/browser/ui/zoom/zoom_controller_browsertest.cc

 // Copyright 2014 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 "components/zoom/zoom_controller.h"
 
 #include "base/macros.h"
 #include "base/process/kill.h"
 #include "build/build_config.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #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"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "content/public/browser/host_zoom_map.h"
 #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"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using zoom::ZoomController;
 using zoom::ZoomObserver;
 
 bool operator==(const ZoomController::ZoomChangedEventData& lhs,
                 const ZoomController::ZoomChangedEventData& rhs) {
@@ skipping 28 matching lines @@
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ZoomChangedWatcher);
 };
 
 class ZoomControllerBrowserTest : public InProcessBrowserTest {
  public:
   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);
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
         browser(), GURL("about:blank"), 1);
     ZoomController* zoom_controller =
         ZoomController::FromWebContents(web_contents);
     double zoom_level = zoom_controller->GetDefaultZoomLevel();
@@ skipping 239 matching lines @@
       web_contents,
       old_zoom_level,
       new_zoom_level,
       ZoomController::ZOOM_MODE_DEFAULT,
       true);  // We have a non-empty host, so this will be 'true'.
   ZoomChangedWatcher zoom_change_watcher(web_contents, zoom_change_data);
   zoom_controller->SetZoomLevel(new_zoom_level);
   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());
+}