Add a test checking that compositor works in a reused renderer.

content/browser/renderer_host/render_widget_host_view_browsertest.cc

 // Copyright (c) 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/paint/skia_paint_canvas.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/browser/renderer_host/render_widget_host_view_frame_subscriber.h"
+#include "content/common/frame_messages.h"
+#include "content/common/view_messages.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.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_utils.h"
 #include "content/shell/browser/shell.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "net/base/filename_util.h"
+#include "net/dns/mock_host_resolver.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/display/display_switches.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
@@ skipping 148 matching lines @@
     run_loop.Run();
   }
 
  private:
   const gfx::Size frame_size_;
   base::FilePath test_dir_;
   int callback_invoke_count_;
   int frames_captured_;
 };
 
+class SwapCompositorFrameWaiter : public WebContentsObserver {

[Saman Sami, 2017/04/03 21:51:30]

This class is very similar to content::FrameWatcher. Please see if you can use
that class to simplify your test. The only difference is that FrameWatcher lacks
a timeout, but maybe you can add a timeout  to FrameWatcher or just get rid of
the timeout and the test will naturally fail if it takes too long.

[Alexander Semashko, 2017/04/17 18:16:20]

Done. Adding timeout to FrameWatcher is not worth it, I think.

+ public:
+  explicit SwapCompositorFrameWaiter(WebContents* web_contents)
+      : WebContentsObserver(web_contents) {}
+
+  void Wait() { RunThisRunLoop(&run_loop_); }
+
+  void WaitWithTimeout(const base::TimeDelta& timeout) {
+    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
+                                   run_loop_.QuitClosure(), timeout);
+    Wait();
+  }
+
+  bool frame_swapped() const { return frame_swapped_; }
+
+ private:
+  void OnSwapCompositorFrame() {
+    frame_swapped_ = true;
+    run_loop_.Quit();
+  }
+
+  bool OnMessageReceived(const IPC::Message& message) override {
+    IPC_BEGIN_MESSAGE_MAP(SwapCompositorFrameWaiter, message)
+      IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_SwapCompositorFrame,
+                                  OnSwapCompositorFrame())
+    IPC_END_MESSAGE_MAP()
+    return false;
+  }
+
+  base::RunLoop run_loop_;
+  bool frame_swapped_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(SwapCompositorFrameWaiter);
+};
+
+// Helps to ensure that a navigation is committed after a compositor frame was
+// submitted by the renderer, but before corresponding ACK is sent back.
+class CommitBeforeSwapAckSentHelper : public WebContentsObserver {
+ public:
+  explicit CommitBeforeSwapAckSentHelper(WebContents* web_contents)
+      : WebContentsObserver(web_contents) {}
+
+ private:
+  void WaitForSwapCompositorFrame() {
+    SwapCompositorFrameWaiter(web_contents()).Wait();
+  }
+
+  bool OnMessageReceived(const IPC::Message& message,
+                         RenderFrameHost* rfh) override {
+    IPC_BEGIN_MESSAGE_MAP(CommitBeforeSwapAckSentHelper, message)
+      IPC_MESSAGE_HANDLER_GENERIC(FrameHostMsg_DidCommitProvisionalLoad,
+                                  WaitForSwapCompositorFrame())
+    IPC_END_MESSAGE_MAP()
+    return false;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(CommitBeforeSwapAckSentHelper);
+};
+
+using RenderWidgetHostViewBrowserTestBase = ContentBrowserTest;
+
+IN_PROC_BROWSER_TEST_F(RenderWidgetHostViewBrowserTestBase,
+                       SendFrameSwapAckOnNavigateAway) {
+  host_resolver()->AddRule("*", "127.0.0.1");
+  ASSERT_TRUE(embedded_test_server()->Start());
+  // Load a page that draws new frames infinitely.
+  NavigateToURL(shell(),
+                embedded_test_server()->GetURL("/page_with_animation.html"));
+
+  // Open a new page in the same renderer to keep it alive.
+  ShellAddedObserver shao;
+  EXPECT_TRUE(
+      ExecuteScript(shell()->web_contents(), "window.open('about:blank');"));
+  EXPECT_TRUE(WaitForLoadStop(shao.GetShell()->web_contents()));
+
+  // Start a cross-process navigation.
+  shell()->LoadURL(embedded_test_server()->GetURL("foo.com", "/title1.html"));
+
+  // When the navigation is about to commit, wait for the next frame to be
+  // submitted by the renderer before proceeding with page load.
+  {
+    CommitBeforeSwapAckSentHelper commit_helper(shell()->web_contents());
+    EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
+    EXPECT_NE(shell()->web_contents()->GetRenderProcessHost(),
+              shao.GetShell()->web_contents()->GetRenderProcessHost());
+  }
+
+  // Go back and verify that the renderer continues to draw new frames.
+  shell()->GoBackOrForward(-1);
+  EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
+  SwapCompositorFrameWaiter frame_waiter(shell()->web_contents());
+  frame_waiter.WaitWithTimeout(base::TimeDelta::FromMilliseconds(500));
+  EXPECT_TRUE(frame_waiter.frame_swapped());
+}
+
 enum CompositingMode {
   GL_COMPOSITING,
   SOFTWARE_COMPOSITING,
 };
 
 class CompositingRenderWidgetHostViewBrowserTest
     : public RenderWidgetHostViewBrowserTest,
       public testing::WithParamInterface<CompositingMode> {
  public:
   CompositingRenderWidgetHostViewBrowserTest()
@@ skipping 721 matching lines @@
                         kTestCompositingModes);
 INSTANTIATE_TEST_CASE_P(
     GLAndSoftwareCompositing,
     CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI,
     kTestCompositingModes);
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace content