Add browsertest that zoom is preserved on reload

content/browser/zoom_browsertest.cc

 // Copyright 2016 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 <vector>
 
 #include "base/strings/string_util.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/shell/browser/shell.h"
 #include "content/test/content_browser_test_utils_internal.h"
 #include "net/dns/mock_host_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
-// This file contains tests to make sure that subframes zoom in a manner
+// This class contains basic tests of zoom functionality.
+class ZoomBrowserTest : public ContentBrowserTest {
+ public:
+  ZoomBrowserTest() {}
+
+ protected:
+  void SetUpOnMainThread() override {
+    host_resolver()->AddRule("*", "127.0.0.1");
+    SetupCrossSiteRedirector(embedded_test_server());
+    ASSERT_TRUE(embedded_test_server()->Start());
+  }
+
+  WebContentsImpl* web_contents() {
+    return static_cast<WebContentsImpl*>(shell()->web_contents());
+  }
+};
+
+
+// This class contains tests to make sure that subframes zoom in a manner
 // consistent with the top-level frame, even when the subframes are cross-site.
 // Particular things we want to make sure of:
 //
 // * Subframes should always have the same zoom level as their main frame, even
 // if the subframe's domain has a different zoom level stored in HostZoomMap.
 //
 // * The condition above should continue to hold after a navigation of the
 // subframe.
 //
 // * Zoom changes applied to the mainframe should propagate to all subframes,
@@ skipping 94 matching lines @@
 
   FrameResizeObserver* toThis() {return this;}
 
   RenderFrameHost* frame_host;
   std::string msg_label;
   bool zoomed_correctly;
   double expected_inner_width;
   double tolerance;
 };
 
+// This struct is used to wait until a resize has occurred.
+struct ResizeObserver {
+  ResizeObserver(RenderFrameHost* host)
+      : frame_host(host) {
+    SetupOnResizeCallback(host);
+  }
+
+  void SetupOnResizeCallback(const ToRenderFrameHost& adapter) {
+    const char kOnResizeCallbackSetup[] =
+        "document.body.onresize = function(){"
+        "  window.domAutomationController.setAutomationId(0);"
+        "  window.domAutomationController.send('Resized');"
+        "};";
+    EXPECT_TRUE(ExecuteScript(
+        adapter, kOnResizeCallbackSetup));
+  }
+
+  bool IsResizeCallback(const std::string& status_msg) {
+    return status_msg == "Resized";
+  }
+
+  RenderFrameHost* frame_host;
+};
+
+void WaitForResize(DOMMessageQueue& msg_queue, ResizeObserver& observer) {
+  std::string status;
+  while (msg_queue.WaitForMessage(&status)) {
+    // Strip the double quotes from the message.
+    status = status.substr(1, status.length() -2);
+    if (observer.IsResizeCallback(status))
+      break;
+  }
+}
+
 void WaitAndCheckFrameZoom(
     DOMMessageQueue& msg_queue,
     std::vector<FrameResizeObserver>& frame_observers) {
   std::string status;
   while (msg_queue.WaitForMessage(&status)) {
     // Strip the double quotes from the message.
     status = status.substr(1, status.length() -2);
 
     bool all_zoomed_correctly = true;
 
     // Use auto& to operate on a reference, and not a copy.
     for (auto& observer : frame_observers) {
       observer.Check(status);
       all_zoomed_correctly = all_zoomed_correctly && observer.zoomed_correctly;
     }
 
     if (all_zoomed_correctly)
       break;
   }
 }
 
 }  // namespace
 
+IN_PROC_BROWSER_TEST_F(ZoomBrowserTest, ZoomPreservedOnReload) {
+  std::string top_level_host("a.com");
+
+  GURL main_url(embedded_test_server()->GetURL(
+      top_level_host, "/cross_site_iframe_factory.html?a(b(a))"));
+  EXPECT_TRUE(NavigateToURL(shell(), main_url));
+  NavigationEntry* entry =
+      web_contents()->GetController().GetLastCommittedEntry();
+  ASSERT_TRUE(entry);
+  GURL loaded_url = HostZoomMap::GetURLFromEntry(entry);
+  EXPECT_EQ(top_level_host, loaded_url.host());
+
+  FrameTreeNode* root =
+      static_cast<WebContentsImpl*>(web_contents())->GetFrameTree()->root();
+  double main_frame_window_border = GetMainframeWindowBorder(web_contents());
+
+  HostZoomMap* host_zoom_map = HostZoomMap::GetForWebContents(web_contents());
+  double default_zoom_level = host_zoom_map->GetDefaultZoomLevel();
+  EXPECT_EQ(0.0, default_zoom_level);
+
+  EXPECT_DOUBLE_EQ(
+      1.0, GetMainFrameZoomFactor(web_contents(), main_frame_window_border));
+
+  const double new_zoom_factor = 2.5;
+
+  // Set the new zoom, wait for the page to be resized, and sanity-check that
+  // the zoom was applied.
+  {
+    DOMMessageQueue msg_queue;
+    ResizeObserver observer(root->current_frame_host());
+
+    const double new_zoom_level =
+        default_zoom_level + ZoomFactorToZoomLevel(new_zoom_factor);
+    host_zoom_map->SetZoomLevelForHost(top_level_host, new_zoom_level);
+
+    WaitForResize(msg_queue, observer);
+  }
+
+  // Make this comparison approximate for Nexus5X test;
+  // https://crbug.com/622858.
+  EXPECT_NEAR(
+      new_zoom_factor,
+      GetMainFrameZoomFactor(web_contents(), main_frame_window_border),
+      0.01);
+
+  // Now the actual test: Reload the page and check that the main frame is
+  // still properly zoomed.
+  WindowedNotificationObserver load_stop_observer(
+      NOTIFICATION_LOAD_STOP,
+      NotificationService::AllSources());
+  shell()->Reload();
+  load_stop_observer.Wait();
+
+  EXPECT_NEAR(

[wjmaclean, 2017/01/03 16:30:30]

Do we need to watch for any resize (or similar) events to make sure the previous
zoom level is properly re-applied once everything settles?

[blundell, 2017/01/03 16:36:57]

That's an interesting question. Do you know if a resize event fires in this
case, i.e., does the page load at default zoom and then have its zoom changed?
If so, I would have expected that the way I've written the test here would fail,
since I'm not waiting for any such event before checking that the page is
zoomed.

+      new_zoom_factor,
+      GetMainFrameZoomFactor(web_contents(), main_frame_window_border),
+      0.01);
+}
+
 IN_PROC_BROWSER_TEST_F(IFrameZoomBrowserTest, SubframesZoomProperly) {
   std::string top_level_host("a.com");
   GURL main_url(embedded_test_server()->GetURL(
       top_level_host, "/cross_site_iframe_factory.html?a(b(a))"));
   EXPECT_TRUE(NavigateToURL(shell(), main_url));
   NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
   ASSERT_TRUE(entry);
   GURL loaded_url = HostZoomMap::GetURLFromEntry(entry);
   EXPECT_EQ(top_level_host, loaded_url.host());
@@ skipping 298 matching lines @@
   EXPECT_EQ(redirect_url, web_contents()->GetLastCommittedURL());
 
   EXPECT_NEAR(
       kZoomFactorForRedirectedHost,
       GetMainFrameZoomFactor(web_contents(), main_frame_window_border),
       0.001);
 }
 #endif
 
 }  // namespace content