Implement screen orientation for out-of-process iframes.

content/browser/screen_orientation/screen_orientation_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 <stdlib.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "build/build_config.h"
+#include "content/browser/frame_host/frame_tree.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/page_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.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/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/common/shell_switches.h"
+#include "net/dns/mock_host_resolver.h"
 #include "ui/compositor/compositor_switches.h"
+#include "ui/display/screen.h"
 
 namespace content {
 
 class ScreenOrientationBrowserTest : public ContentBrowserTest  {
  public:
   ScreenOrientationBrowserTest() {
   }
 
+  WebContentsImpl* web_contents() {
+    return static_cast<WebContentsImpl*>(shell()->web_contents());
+  }
+
  protected:
   void SendFakeScreenOrientation(unsigned angle, const std::string& strType) {
-    RenderWidgetHost* rwh = shell()->web_contents()->GetRenderWidgetHostView()
-        ->GetRenderWidgetHost();
+    RenderWidgetHost* main_frame_rwh =
+        web_contents()->GetMainFrame()->GetRenderWidgetHost();
     ScreenInfo screen_info;
-    rwh->GetScreenInfo(&screen_info);
+    main_frame_rwh->GetScreenInfo(&screen_info);
     screen_info.orientation_angle = angle;
 
     ScreenOrientationValues type = SCREEN_ORIENTATION_VALUES_DEFAULT;
     if (strType == "portrait-primary") {
       type = SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY;
     } else if (strType == "portrait-secondary") {
       type = SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY;
     } else if (strType == "landscape-primary") {
       type = SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY;
     } else if (strType == "landscape-secondary") {
       type = SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY;
     }
     ASSERT_NE(SCREEN_ORIENTATION_VALUES_DEFAULT, type);
     screen_info.orientation_type = type;
 
     ResizeParams params;
     params.screen_info = screen_info;
     params.new_size = gfx::Size(0, 0);
     params.physical_backing_size = gfx::Size(300, 300);
     params.top_controls_height = 0.f;
     params.browser_controls_shrink_blink_size = false;
     params.is_fullscreen_granted = false;
-    rwh->Send(new ViewMsg_Resize(rwh->GetRoutingID(), params));
+
+    std::set<RenderWidgetHost*> rwhs;
+    for (RenderFrameHost* rfh : web_contents()->GetAllFrames()) {
+      if (rfh == web_contents()->GetMainFrame())
+        continue;
+
+      rwhs.insert(static_cast<RenderFrameHostImpl*>(rfh)
+                      ->frame_tree_node()
+                      ->render_manager()
+                      ->GetRenderWidgetHostView()
+                      ->GetRenderWidgetHost());
+    }
+
+    main_frame_rwh->Send(
+        new ViewMsg_Resize(main_frame_rwh->GetRoutingID(), params));
+    web_contents()->GetFrameTree()->root()->render_manager()->SendPageMessage(
+        new PageMsg_UpdateScreenInfo(MSG_ROUTING_NONE, screen_info), nullptr);
+    for (auto* rwh : rwhs)
+      rwh->Send(new ViewMsg_Resize(rwh->GetRoutingID(), params));

[nasko, 2017/04/25 19:59:08]

Do we actually iterate through RWHs in real code when changing orientation?

[lfg, 2017/04/25 20:08:18]

Not exactly like this, the test is faking it. What really happens is:
1. The top-level frame is resized, we send the ViewMsg_Resize to it.
2. This calls delegate->RenderWidgetWasResized, which triggers the
MainFrameWasResized observer that sends the PageMsg_UpdateScreenInfo to the
OOPIF subframes.
3. (1) will cause the renderer to call FrameRectsChanged on the
RenderFrameProxy.
4. This will send an IPC to the browser that will cause the browser to send
ViewMsg_Resize to the subframe renderer.
5. Repeat 3-4 for nested subframe renderers.

I tried writing a test that actually used the whole code path for this, but it
proved to be fairly complicated, as we would have to mock either WebContentsImpl
itself or all of the RenderWidgetHostViews for every platform plus
RenderWidgetHostViewChildFrame. So this test only really tests that the renderer
is doing the correct thing (it is the same for the other screen orientation
tests).

   }
 
   int GetOrientationAngle() {
     int angle;
     ExecuteScriptAndGetValue(shell()->web_contents()->GetMainFrame(),
                              "screen.orientation.angle")->GetAsInteger(&angle);
     return angle;
   }
 
   std::string GetOrientationType() {
@@ skipping 21 matching lines @@
     int angle;
     ExecuteScriptAndGetValue(shell()->web_contents()->GetMainFrame(),
                              "window.orientation")->GetAsInteger(&angle);
     return angle;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScreenOrientationBrowserTest);
 };
 
+class ScreenOrientationOOPIFBrowserTest : public ScreenOrientationBrowserTest {
+ public:
+  ScreenOrientationOOPIFBrowserTest() {}
+
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    IsolateAllSitesForTesting(command_line);
+  }
+
+  void SetUpOnMainThread() override {
+    host_resolver()->AddRule("*", "127.0.0.1");
+    SetupCrossSiteRedirector(embedded_test_server());
+    ASSERT_TRUE(embedded_test_server()->Start());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScreenOrientationOOPIFBrowserTest);
+};
+
 // This test doesn't work on MacOS X but the reason is mostly because it is not
 // used Aura. It could be set as !defined(OS_MACOSX) but the rule below will
 // actually support MacOS X if and when it switches to Aura.
 #if defined(USE_AURA) || defined(OS_ANDROID)
 // Flaky on Chrome OS: http://crbug.com/468259
 #if defined(OS_CHROMEOS)
 #define MAYBE_ScreenOrientationChange DISABLED_ScreenOrientationChange
 #else
 #define MAYBE_ScreenOrientationChange ScreenOrientationChange
 #endif
@@ skipping 126 matching lines @@
     ASSERT_TRUE(ExecuteScript(shell(), "run();"));
 
     TestNavigationObserver navigation_observer(shell()->web_contents(), 1);
     navigation_observer.Wait();
     EXPECT_EQ("NotSupportedError",
               shell()->web_contents()->GetLastCommittedURL().ref());
   }
 }
 #endif // defined(OS_ANDROID)
 
+IN_PROC_BROWSER_TEST_F(ScreenOrientationOOPIFBrowserTest, ScreenOrientation) {
+  GURL main_url(embedded_test_server()->GetURL(
+      "a.com", "/cross_site_iframe_factory.html?a(b)"));
+  EXPECT_TRUE(NavigateToURL(shell(), main_url));
+#if USE_AURA || defined(OS_ANDROID)
+  WaitForResizeComplete(shell()->web_contents());
+#endif  // USE_AURA || defined(OS_ANDROID)
+
+  std::string types[] = {"portrait-primary", "portrait-secondary",
+                         "landscape-primary", "landscape-secondary"};
+
+  int angle = GetOrientationAngle();
+
+  FrameTreeNode* root = web_contents()->GetFrameTree()->root();
+  FrameTreeNode* child = root->child_at(0);
+  MainThreadFrameObserver root_observer(
+      root->current_frame_host()->GetRenderWidgetHost());
+  MainThreadFrameObserver child_observer(
+      child->current_frame_host()->GetRenderWidgetHost());
+  for (int i = 0; i < 4; ++i) {
+    angle = (angle + 90) % 360;
+    SendFakeScreenOrientation(angle, types[i]);
+
+    root_observer.Wait();
+    child_observer.Wait();
+
+    int orientation_angle;
+    std::string orientation_type;
+
+    EXPECT_TRUE(ExecuteScriptAndExtractInt(
+        root->current_frame_host(),
+        "window.domAutomationController.send(screen.orientation.angle)",
+        &orientation_angle));
+    EXPECT_EQ(angle, orientation_angle);
+    EXPECT_TRUE(ExecuteScriptAndExtractInt(
+        child->current_frame_host(),
+        "window.domAutomationController.send(screen.orientation.angle)",
+        &orientation_angle));
+    EXPECT_EQ(angle, orientation_angle);
+
+    EXPECT_TRUE(ExecuteScriptAndExtractString(
+        root->current_frame_host(),
+        "window.domAutomationController.send(screen.orientation.type)",
+        &orientation_type));
+    EXPECT_EQ(types[i], orientation_type);
+    EXPECT_TRUE(ExecuteScriptAndExtractString(
+        child->current_frame_host(),
+        "window.domAutomationController.send(screen.orientation.type)",
+        &orientation_type));
+    EXPECT_EQ(types[i], orientation_type);
+  }
+}
+
 } // namespace content