cc: Remove the non-implside flavour of LayerTreeTests.

While doing so I audited a bunch of MULTI_THREAD only tests and turned
them into SINGLE_AND_MULTI_THREAD or documented why not to. Some of the
NOIMPL tests really are NOIMPL and I deleted them. The others I turned
on with impl-side instead.

NOTE TO PERF SHERIFFS: This changes the names of some cc_perftests and
makes some of them use impl-side painting now. If this has perf side-
effects these should be considered new (more accurate) baselines.

R=enne@chromium.org, enne, vmpstr
BUG=413479
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1180613010.

Cr-Commit-Position: refs/heads/master@{#334286}

cc/layers/scrollbar_layer_unittest.cc

@@ -682,7 +682,7 @@ TEST_F(ScrollbarLayerTestMaxTextureSize, DirectRenderer) {
   int max_size = 0;
   context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
   SetScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
-  RunTest(true, false, true);
+  RunTest(true, false);
 }
 
 TEST_F(ScrollbarLayerTestMaxTextureSize, DelegatingRenderer) {
@@ -691,7 +691,7 @@ TEST_F(ScrollbarLayerTestMaxTextureSize, DelegatingRenderer) {
   int max_size = 0;
   context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
   SetScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
-  RunTest(true, true, true);
+  RunTest(true, true);
 }
 
 class ScrollbarLayerTestResourceCreationAndRelease : public ScrollbarLayerTest {

cc/test/layer_tree_pixel_test.cc

@@ -30,8 +30,7 @@ namespace cc {
 LayerTreePixelTest::LayerTreePixelTest()
     : pixel_comparator_(new ExactPixelComparator(true)),
       test_type_(PIXEL_TEST_GL),
-      pending_texture_mailbox_callbacks_(0),
-      impl_side_painting_(true) {
+      pending_texture_mailbox_callbacks_(0) {
 }
 
 LayerTreePixelTest::~LayerTreePixelTest() {}
@@ -203,7 +202,7 @@ void LayerTreePixelTest::RunPixelTest(
   readback_target_ = NULL;
   ref_file_ = file_name;
   bool threaded = true;
-  RunTest(threaded, false, impl_side_painting_);
+  RunTest(threaded, false);
 }
 
 void LayerTreePixelTest::RunSingleThreadedPixelTest(
@@ -215,7 +214,7 @@ void LayerTreePixelTest::RunSingleThreadedPixelTest(
   readback_target_ = NULL;
   ref_file_ = file_name;
   bool threaded = false;
-  RunTest(threaded, false, impl_side_painting_);
+  RunTest(threaded, false);
 }
 
 void LayerTreePixelTest::RunPixelTestWithReadbackTarget(
@@ -227,7 +226,7 @@ void LayerTreePixelTest::RunPixelTestWithReadbackTarget(
   content_root_ = content_root;
   readback_target_ = target;
   ref_file_ = file_name;
-  RunTest(true, false, impl_side_painting_);
+  RunTest(true, false);
 }
 
 void LayerTreePixelTest::SetupTree() {

cc/test/layer_tree_pixel_test.h

@@ -109,7 +109,6 @@ class LayerTreePixelTest : public LayerTreeTest {
   scoped_ptr<SkBitmap> result_bitmap_;
   std::vector<scoped_refptr<TextureLayer>> texture_layers_;
   int pending_texture_mailbox_callbacks_;
-  bool impl_side_painting_;
   gfx::Vector2d enlarge_texture_amount_;
 };
 

cc/test/layer_tree_test.cc

@@ -319,7 +319,6 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
   }
 
   void BlockNotifyReadyToActivateForTesting(bool block) override {
-    CHECK(settings().impl_side_painting);
     CHECK(proxy()->ImplThreadTaskRunner())
         << "Not supported for single-threaded mode.";
     block_notify_ready_to_activate_for_testing_ = block;
@@ -786,9 +785,7 @@ void LayerTreeTest::DispatchCompositeImmediately() {
     layer_tree_host_->Composite(base::TimeTicks::Now());
 }
 
-void LayerTreeTest::RunTest(bool threaded,
-                            bool delegating_renderer,
-                            bool impl_side_painting) {
+void LayerTreeTest::RunTest(bool threaded, bool delegating_renderer) {
   if (threaded) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
@@ -806,9 +803,10 @@ void LayerTreeTest::RunTest(bool threaded,
   // mocked out.
   settings_.renderer_settings.refresh_rate = 200.0;
   settings_.background_animation_rate = 200.0;
-  settings_.impl_side_painting = impl_side_painting;
+  settings_.impl_side_painting = true;
   settings_.verify_property_trees = verify_property_trees_;
   InitializeSettings(&settings_);
+  DCHECK(settings_.impl_side_painting);
   InitializeLayerSettings(&layer_settings_);
 
   main_task_runner_->PostTask(
@@ -837,10 +835,6 @@ void LayerTreeTest::RunTest(bool threaded,
   AfterTest();
 }
 
-void LayerTreeTest::RunTestWithImplSidePainting() {
-  RunTest(true, false, true);
-}
-
 void LayerTreeTest::RequestNewOutputSurface() {
   layer_tree_host_->SetOutputSurface(CreateOutputSurface());
 }

cc/test/layer_tree_test.h

@@ -180,10 +180,7 @@ class LayerTreeTest : public testing::Test, public TestHooks {
   virtual void BeginTest() = 0;
   virtual void SetupTree();
 
-  virtual void RunTest(bool threaded,
-                       bool delegating_renderer,
-                       bool impl_side_painting);
-  virtual void RunTestWithImplSidePainting();
+  virtual void RunTest(bool threaded, bool delegating_renderer);
 
   bool HasImplThread() { return !!impl_thread_; }
   base::SingleThreadTaskRunner* ImplThreadTaskRunner() {
@@ -256,140 +253,53 @@ class LayerTreeTest : public testing::Test, public TestHooks {
 
 }  // namespace cc
 
-#define SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)        \
-  TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DirectRenderer_MainThreadPaint) { \
-    RunTest(false, false, false);                                             \
-  }                                                                           \
-  class SingleThreadDirectNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
-
-#define SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)        \
-  TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DirectRenderer_ImplSidePaint) { \
-    RunTest(false, false, true);                                            \
-  }                                                                         \
+#define SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DirectRenderer) {   \
+    RunTest(false, false);                                      \
+  }                                                             \
   class SingleThreadDirectImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 
-#define SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
-  SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME) \
-  TEST_F(TEST_FIXTURE_NAME,                                                \
-         RunSingleThread_DelegatingRenderer_MainThreadPaint) {             \
-    RunTest(false, true, false);                                           \
-  }                                                                        \
-  class SingleThreadDelegatingNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
-
-#define SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME) \
-  TEST_F(TEST_FIXTURE_NAME,                                              \
-         RunSingleThread_DelegatingRenderer_ImplSidePaint) {             \
-    RunTest(false, true, true);                                          \
-  }                                                                      \
+#define SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunSingleThread_DelegatingRenderer) {   \
+    RunTest(false, true);                                           \
+  }                                                                 \
   class SingleThreadDelegatingImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 
-#define SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
-  SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define SINGLE_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME)            \
-  SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define SINGLE_THREAD_IMPL_TEST_F(TEST_FIXTURE_NAME)            \
-  SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
-  SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
 #define SINGLE_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
   SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
   SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
-#define MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)        \
-  TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DirectRenderer_MainThreadPaint) { \
-    RunTest(true, false, false);                                             \
-  }                                                                          \
-  class MultiThreadDirectNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
-
-#define MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)        \
-  TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DirectRenderer_ImplSidePaint) { \
-    RunTest(true, false, true);                                            \
-  }                                                                        \
+#define MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DirectRenderer) {   \
+    RunTest(true, false);                                      \
+  }                                                            \
   class MultiThreadDirectImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 
-#define MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
-  MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME) \
-  TEST_F(TEST_FIXTURE_NAME,                                               \
-         RunMultiThread_DelegatingRenderer_MainThreadPaint) {             \
-    RunTest(true, true, false);                                           \
-  }                                                                       \
-  class MultiThreadDelegatingNoImplNeedsSemicolon##TEST_FIXTURE_NAME {}
-
-#define MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)        \
-  TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DelegatingRenderer_ImplSidePaint) { \
-    RunTest(true, true, true);                                                 \
-  }                                                                            \
+#define MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
+  TEST_F(TEST_FIXTURE_NAME, RunMultiThread_DelegatingRenderer) {   \
+    RunTest(true, true);                                           \
+  }                                                                \
   class MultiThreadDelegatingImplNeedsSemicolon##TEST_FIXTURE_NAME {}
 
-#define MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)   \
-  MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define MULTI_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME)            \
-  MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define MULTI_THREAD_IMPL_TEST_F(TEST_FIXTURE_NAME)            \
-  MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
 #define MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
   MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
   MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
-#define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(    \
-    TEST_FIXTURE_NAME)                                            \
-  SINGLE_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME) \
-  SINGLE_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME);                \
-  MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
 #define SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
   SINGLE_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME);                \
   MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
-#define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(    \
-    TEST_FIXTURE_NAME)                                                \
-  SINGLE_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(    \
-    TEST_FIXTURE_NAME)                                              \
-  SINGLE_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
-  MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
 #define SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME) \
   SINGLE_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME);                \
   MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
-#define SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME)            \
-  SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME); \
-  SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(TEST_FIXTURE_NAME)
-
-#define SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(TEST_FIXTURE_NAME)            \
-  SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME); \
-  SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_IMPL_TEST_F(TEST_FIXTURE_NAME)
-
 #define SINGLE_AND_MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)            \
   SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(TEST_FIXTURE_NAME); \
   SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(TEST_FIXTURE_NAME)
 
 // Some tests want to control when notify ready for activation occurs,
 // but this is not supported in the single-threaded case.
-#define SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F(TEST_FIXTURE_NAME) \
-  SINGLE_THREAD_NOIMPL_TEST_F(TEST_FIXTURE_NAME);                     \
+#define MULTI_THREAD_BLOCKNOTIFY_TEST_F(TEST_FIXTURE_NAME) \
   MULTI_THREAD_TEST_F(TEST_FIXTURE_NAME)
 
 #endif  // CC_TEST_LAYER_TREE_TEST_H_

cc/trees/layer_tree_host_common_perftest.cc

@@ -77,48 +77,9 @@ class LayerTreeHostCommonPerfTest : public LayerTreeTest {
   std::string json_;
 };
 
-class CalcDrawPropsMainTest : public LayerTreeHostCommonPerfTest {
+class CalcDrawPropsTest : public LayerTreeHostCommonPerfTest {
  public:
-  void RunCalcDrawProps() { RunTest(false, false, false); }
-
-  void BeginTest() override {
-    timer_.Reset();
-
-    do {
-      bool can_render_to_separate_surface = true;
-      bool verify_property_trees = false;
-      int max_texture_size = 8096;
-      RenderSurfaceLayerList update_list;
-      PropertyTrees property_trees;
-      LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
-          layer_tree_host()->root_layer(),
-          layer_tree_host()->device_viewport_size(), gfx::Transform(),
-          layer_tree_host()->device_scale_factor(),
-          layer_tree_host()->page_scale_factor(),
-          layer_tree_host()->overscroll_elasticity_layer(),
-          layer_tree_host()->elastic_overscroll(),
-          layer_tree_host()->page_scale_layer(), max_texture_size,
-          layer_tree_host()->settings().can_use_lcd_text,
-          layer_tree_host()->settings().layers_always_allowed_lcd_text,
-          can_render_to_separate_surface,
-          layer_tree_host()
-              ->settings()
-              .layer_transforms_should_scale_layer_contents,
-          verify_property_trees, &update_list, 0, &property_trees);
-      LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-      timer_.NextLap();
-    } while (!timer_.HasTimeLimitExpired());
-
-    EndTest();
-  }
-};
-
-class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
- public:
-  void RunCalcDrawProps() {
-    RunTestWithImplSidePainting();
-  }
+  void RunCalcDrawProps() { RunTest(false, false); }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ -163,10 +124,10 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
   }
 };
 
-class BspTreePerfTest : public CalcDrawPropsImplTest {
+class BspTreePerfTest : public CalcDrawPropsTest {
  public:
   BspTreePerfTest() : num_duplicates_(1) {}
-  void RunSortLayers() { RunTest(false, false, false); }
+  void RunSortLayers() { RunTest(false, false); }
 
   void SetNumberOfDuplicates(int num_duplicates) {
     num_duplicates_ = num_duplicates;
@@ -230,49 +191,25 @@ class BspTreePerfTest : public CalcDrawPropsImplTest {
   int num_duplicates_;
 };
 
-TEST_F(CalcDrawPropsMainTest, TenTen) {
-  SetTestName("10_10_main_thread");
-  ReadTestFile("10_10_layer_tree");
-  RunCalcDrawProps();
-}
-
-TEST_F(CalcDrawPropsMainTest, HeavyPage) {
-  SetTestName("heavy_page_main_thread");
-  ReadTestFile("heavy_layer_tree");
-  RunCalcDrawProps();
-}
-
-TEST_F(CalcDrawPropsMainTest, TouchRegionLight) {
-  SetTestName("touch_region_light_main_thread");
-  ReadTestFile("touch_region_light");
-  RunCalcDrawProps();
-}
-
-TEST_F(CalcDrawPropsMainTest, TouchRegionHeavy) {
-  SetTestName("touch_region_heavy_main_thread");
-  ReadTestFile("touch_region_heavy");
-  RunCalcDrawProps();
-}
-
-TEST_F(CalcDrawPropsImplTest, TenTen) {
+TEST_F(CalcDrawPropsTest, TenTen) {
   SetTestName("10_10");
   ReadTestFile("10_10_layer_tree");
   RunCalcDrawProps();
 }
 
-TEST_F(CalcDrawPropsImplTest, HeavyPage) {
+TEST_F(CalcDrawPropsTest, HeavyPage) {
   SetTestName("heavy_page");
   ReadTestFile("heavy_layer_tree");
   RunCalcDrawProps();
 }
 
-TEST_F(CalcDrawPropsImplTest, TouchRegionLight) {
+TEST_F(CalcDrawPropsTest, TouchRegionLight) {
   SetTestName("touch_region_light");
   ReadTestFile("touch_region_light");
   RunCalcDrawProps();
 }
 
-TEST_F(CalcDrawPropsImplTest, TouchRegionHeavy) {
+TEST_F(CalcDrawPropsTest, TouchRegionHeavy) {
   SetTestName("touch_region_heavy");
   ReadTestFile("touch_region_heavy");
   RunCalcDrawProps();