Parameterize the composited RenderWidgetHostViewBrowserTests.

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 "base/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
@@ skipping 193 matching lines @@
     run_loop.Run();
   }
 
  private:
   const gfx::Size frame_size_;
   base::FilePath test_dir_;
   int callback_invoke_count_;
   int frames_captured_;
 };
 
+enum CompositingMode {
+  GL_COMPOSITING,
+  SOFTWARE_COMPOSITING,
+};
+
 class CompositingRenderWidgetHostViewBrowserTest
-    : public RenderWidgetHostViewBrowserTest {
+    : public RenderWidgetHostViewBrowserTest,
+      public testing::WithParamInterface<CompositingMode> {
  public:
+  explicit CompositingRenderWidgetHostViewBrowserTest()
+      : compositing_mode_(GetParam()) {
+#if !defined(USE_AURA) && !defined(OS_MACOSX)
+    // TODO(danakj): Remove when GTK linux is no more.
+    compositing_mode_ = GL_COMPOSITING;

[sky, 2013/12/19 21:35:32]

Wouldn't this be better placed around INSTANTIATE_TEST_CASE_P as otherwise
you're going to run tests twice with GL_COMPOSITING?

[danakj, 2013/12/19 21:40:54]

Hm! Never heard of such a thing, I'll go look it up.

I had resigned to running twice since it's just GTK which is going away anyway,
but it's good to know about this.

[danakj, 2013/12/19 21:45:31]

Oh, I see what you mean, the INSTANTIATE thing at the bottom. I can change the
values passed to it, good thought.

[danakj, 2013/12/19 22:21:06]

Done.

+#endif
+  }
+
   virtual void SetUp() OVERRIDE {
-    // We expect real pixel output for these tests.
-    UseRealGLContexts();
+    if (compositing_mode_ == SOFTWARE_COMPOSITING) {
+      UseSoftwareCompositing();
+    } else {
+      // We expect real pixel output for these tests.
+      UseRealGLContexts();
 
-    // On legacy windows, these tests need real GL bindings to pass.
 #if defined(OS_WIN) && !defined(USE_AURA)
-    UseRealGLBindings();
+      // On legacy windows, these tests need real GL bindings to pass.
+      UseRealGLBindings();
 #endif
+    }
 
     RenderWidgetHostViewBrowserTest::SetUp();
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Note: Not appending kForceCompositingMode switch here, since not all bots
     // support compositing.  Some bots will run with compositing on, and others
     // won't.  Therefore, the call to SetUpSourceSurface() later on will detect
     // whether compositing mode is actually on or not.  If not, the tests will
     // pass blindly, logging a warning message, since we cannot test what the
@@ skipping 26 matching lines @@
 #if !defined(USE_AURA)
     if (!GetRenderWidgetHost()->is_accelerated_compositing_active())
       return false;  // Renderer did not turn on accelerated compositing.
 #endif
 
     // Using accelerated compositing, but a compositing surface might not be
     // available yet.  So, wait for it.
     WaitForCopySourceReady();
     return true;
   }
+
+  CompositingMode compositing_mode_;

[sky, 2013/12/19 21:35:32]

const and private and DISALLOW_...?

[danakj, 2013/12/19 21:40:54]

Sure, leaky encapsulation in test fixtures has become a bit of habit.

[danakj, 2013/12/19 22:21:06]

Done.

 };
 
 class NonCompositingRenderWidgetHostViewBrowserTest
     : public RenderWidgetHostViewBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Note: Appending the kDisableAcceleratedCompositing switch here, but there
     // are some builds that only use compositing and will ignore this switch.
     // Therefore, the call to SetUpSourceSurface() later on will detect whether
     // compositing mode is actually off.  If it's on, the tests will pass
@@ skipping 54 matching lines @@
  private:
   DeliverFrameCallback callback_;
 };
 
 // Disable tests for Android and IOS as these platforms have incomplete
 // implementation.
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 
 // The CopyFromBackingStore() API should work on all platforms when compositing
 // is enabled.
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore) {
   RunBasicCopyFromBackingStoreTest();
 }
 
 // The CopyFromBackingStore() API should work on all platforms when compositing
 // is disabled.
 IN_PROC_BROWSER_TEST_F(NonCompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore) {
   RunBasicCopyFromBackingStoreTest();
 }
 
 // Tests that the callback passed to CopyFromBackingStore is always called,
 // even when the RenderWidgetHost is deleting in the middle of an async copy.
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore_CallbackDespiteDelete) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
 
   base::RunLoop run_loop;
   GetRenderViewHost()->CopyFromBackingStore(
       gfx::Rect(),
       frame_size(),
       base::Bind(&RenderWidgetHostViewBrowserTest::FinishCopyFromBackingStore,
                  base::Unretained(this), run_loop.QuitClosure()));
   // Delete the surface before the callback is run.
   GetRenderWidgetHostViewPort()->AcceleratedSurfaceRelease();
   run_loop.Run();
 
   EXPECT_EQ(1, callback_invoke_count());
 }
 
 // Tests that the callback passed to CopyFromCompositingSurfaceToVideoFrame is
 // always called, even when the RenderWidgetHost is deleting in the middle of
 // an async copy.
 //
 // Test is flaky on Win Aura. http://crbug.com/276783
 #if (defined(OS_WIN) && defined(USE_AURA)) || \
     (defined(OS_CHROMEOS) && !defined(NDEBUG))
 #define MAYBE_CopyFromCompositingSurface_CallbackDespiteDelete \
   DISABLED_CopyFromCompositingSurface_CallbackDespiteDelete
 #else
 #define MAYBE_CopyFromCompositingSurface_CallbackDespiteDelete \
   CopyFromCompositingSurface_CallbackDespiteDelete
 #endif
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
                        MAYBE_CopyFromCompositingSurface_CallbackDespiteDelete) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanCopyToVideoFrame()) {
     LOG(WARNING) <<
         ("Blindly passing this test: CopyFromCompositingSurfaceToVideoFrame() "
          "not supported on this platform.");
     return;
   }
 
@@ skipping 14 matching lines @@
 // With compositing turned off, no platforms should support the
 // CopyFromCompositingSurfaceToVideoFrame() API.
 IN_PROC_BROWSER_TEST_F(NonCompositingRenderWidgetHostViewBrowserTest,
                        CopyFromCompositingSurfaceToVideoFrameCallbackTest) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   EXPECT_FALSE(GetRenderWidgetHostViewPort()->CanCopyToVideoFrame());
 }
 
 // Test basic frame subscription functionality.  We subscribe, and then run
 // until at least one DeliverFrameCallback has been invoked.
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
                        FrameSubscriberTest) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanSubscribeFrame()) {
     LOG(WARNING) << ("Blindly passing this test: Frame subscription not "
                      "supported on this platform.");
     return;
   }
 
   base::RunLoop run_loop;
   scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
       new FakeFrameSubscriber(
           base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
                      base::Unretained(this),
                      base::MessageLoopProxy::current(),
                      run_loop.QuitClosure())));
   view->BeginFrameSubscription(subscriber.Pass());
   run_loop.Run();
   view->EndFrameSubscription();
 
   EXPECT_LE(1, callback_invoke_count());
   EXPECT_LE(1, frames_captured());
 }
 
 // Test that we can copy twice from an accelerated composited page.
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest, CopyTwice) {
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest, CopyTwice) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanCopyToVideoFrame()) {
     LOG(WARNING) << ("Blindly passing this test: "
                      "CopyFromCompositingSurfaceToVideoFrame() not supported "
                      "on this platform.");
     return;
   }
 
   base::RunLoop run_loop;
@@ skipping 285 matching lines @@
   }
 
  private:
   bool expected_copy_from_compositing_surface_result_;
   SkBitmap expected_copy_from_compositing_surface_bitmap_;
   int allowable_error_;
   gfx::Rect exclude_rect_;
   std::string test_url_;
 };
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
                        CopyFromCompositingSurface_Origin_Unscaled) {
   gfx::Rect copy_rect(400, 300);
   gfx::Size output_size = copy_rect.size();
   gfx::Size expected_bitmap_size = output_size;
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
                        CopyFromCompositingSurface_Origin_Scaled) {
   gfx::Rect copy_rect(400, 300);
   gfx::Size output_size(200, 100);
   gfx::Size expected_bitmap_size = output_size;
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
                        CopyFromCompositingSurface_Cropped_Unscaled) {
   // Grab 60x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(30, 30),
                         gfx::Size(60, 60));
   gfx::Size output_size = copy_rect.size();
   gfx::Size expected_bitmap_size = output_size;
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
                        CopyFromCompositingSurface_Cropped_Scaled) {
   // Grab 60x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(30, 30),
                         gfx::Size(60, 60));
   gfx::Size output_size(20, 10);
   gfx::Size expected_bitmap_size = output_size;
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
                        CopyFromCompositingSurface_ForVideoFrame) {
   // Grab 90x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(45, 30),
                         gfx::Size(90, 60));
   gfx::Size output_size = copy_rect.size();
   gfx::Size expected_bitmap_size = output_size;
   gfx::Size html_rect_size(400, 300);
   bool video_frame = true;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
                        CopyFromCompositingSurface_ForVideoFrame_Scaled) {
   // Grab 90x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(45, 30),
                         gfx::Size(90, 60));
   // Scale to 30 x 20 (preserve aspect ratio).
   gfx::Size output_size(30, 20);
   gfx::Size expected_bitmap_size = output_size;
   gfx::Size html_rect_size(400, 300);
   bool video_frame = true;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
 class CompositingRenderWidgetHostViewTabCaptureHighDPI
     : public CompositingRenderWidgetHostViewBrowserTestTabCapture {
  public:
-  CompositingRenderWidgetHostViewTabCaptureHighDPI()
-      : kScale(2.f) {
-  }
+  CompositingRenderWidgetHostViewTabCaptureHighDPI() : kScale(2.f) {}
 
   virtual void SetUpCommandLine(CommandLine* cmd) OVERRIDE {
     CompositingRenderWidgetHostViewBrowserTestTabCapture::SetUpCommandLine(cmd);
     cmd->AppendSwitchASCII(switches::kForceDeviceScaleFactor,
                            base::StringPrintf("%f", scale()));
 #if defined(OS_WIN)
     cmd->AppendSwitchASCII(switches::kHighDPISupport, "1");
     gfx::EnableHighDPISupport();
 #endif
   }
 
   float scale() const { return kScale; }
 
  private:
   virtual bool ShouldContinueAfterTestURLLoad() OVERRIDE {
     PASS_TEST_IF_SCALE_FACTOR_NOT_SUPPORTED(scale());
     return true;
   }
 
   const float kScale;
 
   DISALLOW_COPY_AND_ASSIGN(CompositingRenderWidgetHostViewTabCaptureHighDPI);
 };
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewTabCaptureHighDPI,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewTabCaptureHighDPI,
                        CopyFromCompositingSurface) {
   gfx::Rect copy_rect(200, 150);
   gfx::Size output_size = copy_rect.size();
   gfx::Size expected_bitmap_size =
       gfx::ToFlooredSize(gfx::ScaleSize(output_size, scale(), scale()));
   gfx::Size html_rect_size(200, 150);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
-IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewTabCaptureHighDPI,
+IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewTabCaptureHighDPI,
                        CopyFromCompositingSurfaceVideoFrame) {
   gfx::Size html_rect_size(200, 150);
   // Grab 90x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect =
       gfx::Rect(gfx::Rect(html_rect_size).CenterPoint() - gfx::Vector2d(45, 30),
                 gfx::Size(90, 60));
   gfx::Size output_size = copy_rect.size();
   gfx::Size expected_bitmap_size =
       gfx::ToFlooredSize(gfx::ScaleSize(output_size, scale(), scale()));
   bool video_frame = true;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 expected_bitmap_size,
                                 video_frame);
 }
 
+INSTANTIATE_TEST_CASE_P(GLAndSoftware,
+                        CompositingRenderWidgetHostViewBrowserTest,
+                        testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
+INSTANTIATE_TEST_CASE_P(GLAndSoftware,
+                        CompositingRenderWidgetHostViewBrowserTestTabCapture,
+                        testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
+INSTANTIATE_TEST_CASE_P(GLAndSoftware,
+                        CompositingRenderWidgetHostViewTabCaptureHighDPI,
+                        testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
+
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 }  // namespace
 }  // namespace content