Add threaded-compositor test mode to throughput_tests

chrome/test/perf/rendering/throughput_tests.cc

 // Copyright (c) 2012 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/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 36 matching lines @@
 
 enum RunTestFlags {
   kNone = 0,
   kInternal = 1 << 0,         // Test uses internal test data.
   kAllowExternalDNS = 1 << 1, // Test needs external DNS lookup.
   kIsGpuCanvasTest = 1 << 2   // Test uses GPU accelerated canvas features.
 };
 
 enum ThroughputTestFlags {
   kSW = 0,
-  kGPU = 1 << 0
+  kGPU = 1 << 0,
+  kCompositorThread = 1 << 1
 };
 
 const int kSpinUpTimeMs = 4 * 1000;
 const int kRunTimeMs = 10 * 1000;
 const int kIgnoreSomeFrames = 3;
 
 class ThroughputTest : public BrowserPerfTest {
  public:
-  explicit ThroughputTest(ThroughputTestFlags flags) :
+  explicit ThroughputTest(int flags) :
       use_gpu_(flags & kGPU),
+      use_compositor_thread_(flags & kCompositorThread),
       spinup_time_ms_(kSpinUpTimeMs),
       run_time_ms_(kRunTimeMs) {}
 
   // This indicates running on GPU bots, not necessarily using the GPU.
   bool IsGpuAvailable() const {
     return CommandLine::ForCurrentProcess()->HasSwitch("enable-gpu");
   }
 
   // Parse flags from JSON to control the test behavior.
   bool ParseFlagsFromJSON(const FilePath& json_dir,
@@ skipping 110 matching lines @@
     command_line->AppendSwitch(switches::kDisableGpuVsync);
     command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
     // Enable or disable GPU acceleration.
     if (use_gpu_) {
       command_line->AppendSwitch(switches::kForceCompositingMode);
     } else {
       command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
       command_line->AppendSwitch(switches::kDisableExperimentalWebGL);
       command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
     }
+    if (use_compositor_thread_) {
+      ASSERT_TRUE(use_gpu_);
+      command_line->AppendSwitch(switches::kEnableThreadedCompositing);
+    } else {
+      command_line->AppendSwitch(switches::kDisableThreadedCompositing);
+    }
   }
 
   void Wait(int ms) {
     base::RunLoop run_loop;
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(),
         base::TimeDelta::FromMilliseconds(ms));
     content::RunThisRunLoop(&run_loop);
   }
 
@@ skipping 153 matching lines @@
     // Cull a few leading and trailing events as they might be unreliable.
     TraceEventVector rate_events(frames->begin() + kIgnoreSomeFrames,
                                  frames->end() - kIgnoreSomeFrames);
     trace_analyzer::RateStats stats;
     ASSERT_TRUE(GetRateStats(rate_events, &stats, NULL));
     LOG(INFO) << "FPS = " << 1000000.0 / stats.mean_us;
 
     // Print perf results.
     double mean_ms = stats.mean_us / 1000.0;
     double std_dev_ms = stats.standard_deviation_us / 1000.0 / 1000.0;
-    std::string trace_name = ran_on_gpu ? "gpu" : "software";
+    std::string trace_name = use_compositor_thread_? "gpu_thread" :
+                             ran_on_gpu ? "gpu" : "software";
     std::string mean_and_error = base::StringPrintf("%f,%f", mean_ms,
                                                     std_dev_ms);
     perf_test::PrintResultMeanAndError(test_name, "", trace_name,
                                        mean_and_error, "frame_time", true);
 
     if (flags & kAllowExternalDNS)
       ResetAllowExternalDNS();
 
     // Close the tab so that we can quit without timing out during the
     // wait-for-idle stage in browser_test framework.
@@ skipping 37 matching lines @@
    private:
     int x_;
     int y_;
     int r_;
     int g_;
     int b_;
     Operator op_;
   };
 
   bool use_gpu_;
+  bool use_compositor_thread_;
   int spinup_time_ms_;
   int run_time_ms_;
   FilePath local_cache_path_;
   GURL gurl_;
   scoped_ptr<net::ScopedDefaultHostResolverProc> host_resolver_override_;
   scoped_ptr<WaitPixel> wait_for_pixel_;
 };
 
 // For running tests on GPU:
 class ThroughputTestGPU : public ThroughputTest {
  public:
   ThroughputTestGPU() : ThroughputTest(kGPU) {}
 };
 
+// For running tests on GPU with the compositor thread:
+class ThroughputTestThread : public ThroughputTest {
+ public:
+  ThroughputTestThread() : ThroughputTest(kGPU | kCompositorThread) {}
+};
+
 // For running tests on Software:
 class ThroughputTestSW : public ThroughputTest {
  public:
   ThroughputTestSW() : ThroughputTest(kSW) {}
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 /// Tests
 
 // Run this test with a URL on the command line:
@@ skipping 19 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, DISABLED_TestURL) {
   RunTestWithURL(kAllowExternalDNS);
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, Particles) {
   RunTest("particles", kInternal);
 }
 
+IN_PROC_BROWSER_TEST_F(ThroughputTestThread, Particles) {
+  RunTest("particles", kInternal);
+}
+
 IN_PROC_BROWSER_TEST_F(ThroughputTestSW, CanvasDemoSW) {
   RunTest("canvas-demo", kInternal);
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, CanvasDemoGPU) {
   RunTest("canvas-demo", kInternal | kIsGpuCanvasTest);
 }
 
+IN_PROC_BROWSER_TEST_F(ThroughputTestThread, CanvasDemoGPU) {
+  RunTest("canvas-demo", kInternal | kIsGpuCanvasTest);
+}
+
 // CompositingHugeDivSW timed out on Mac Intel Release GPU bot
 // See crbug.com/114781
 // Stopped producing results in SW: crbug.com/127621
 IN_PROC_BROWSER_TEST_F(ThroughputTestSW, DISABLED_CompositingHugeDivSW) {
   RunTest("compositing_huge_div", kNone);
 }
 
 // Failing with insufficient frames: crbug.com/127595
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, DISABLED_CompositingHugeDivGPU) {
   RunTest("compositing_huge_div", kNone);
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestSW, DrawImageShadowSW) {
   RunTest("canvas2d_balls_with_shadow", kNone);
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, DrawImageShadowGPU) {
   RunTest("canvas2d_balls_with_shadow", kNone | kIsGpuCanvasTest);
 }
 
+IN_PROC_BROWSER_TEST_F(ThroughputTestThread, DrawImageShadowGPU) {
+  RunTest("canvas2d_balls_with_shadow", kNone | kIsGpuCanvasTest);
+}
+
 IN_PROC_BROWSER_TEST_F(ThroughputTestSW, CanvasToCanvasDrawSW) {
   if (IsGpuAvailable() &&
       GPUTestBotConfig::CurrentConfigMatches("MAC AMD"))
     return;
   RunTest("canvas2d_balls_draw_from_canvas", kNone);
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, CanvasToCanvasDrawGPU) {
   if (IsGpuAvailable() &&
       GPUTestBotConfig::CurrentConfigMatches("MAC AMD"))
@@ skipping 32 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestSW, CanvasManyImagesSW) {
   RunCanvasBenchTest("many_images", kNone);
 }
 
 IN_PROC_BROWSER_TEST_F(ThroughputTestGPU, CanvasManyImagesGPU) {
   RunCanvasBenchTest("many_images", kNone | kIsGpuCanvasTest);
 }
 
+IN_PROC_BROWSER_TEST_F(ThroughputTestThread, CanvasManyImagesGPU) {
+  RunCanvasBenchTest("many_images", kNone | kIsGpuCanvasTest);
+}
+
 }  // namespace