Enable some remote LTH tests in layer_tree_host_unittests.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 63 matching lines @@
 using testing::AtLeast;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
 class LayerTreeHostTest : public LayerTreeTest {};
 
 class LayerTreeHostTestHasImplThreadTest : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestHasImplThreadTest() : threaded_(false) {}
+  LayerTreeHostTestHasImplThreadTest() : single_threaded_(false) {}
 
   void RunTest(CompositorMode mode) override {
-    threaded_ = mode == CompositorMode::THREADED;
+    single_threaded_ = mode == CompositorMode::SINGLE_THREADED;
     LayerTreeHostTest::RunTest(mode);
   }
 
   void BeginTest() override {
-    EXPECT_EQ(threaded_, HasImplThread());
+    EXPECT_EQ(single_threaded_, !HasImplThread());
     EndTest();
   }
 
-  void AfterTest() override { EXPECT_EQ(threaded_, HasImplThread()); }
+  void AfterTest() override { EXPECT_EQ(single_threaded_, !HasImplThread()); }
 
  private:
-  bool threaded_;
+  bool single_threaded_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestHasImplThreadTest);

[Khushal, 2016/10/14 20:12:31]

Looks like we didn't actually enable it for remote. :P

[xingliu, 2016/10/17 16:26:49]

My bad. Done.

 
 class LayerTreeHostTestSetNeedsCommitInsideLayout : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void UpdateLayerTreeHost() override {
     // This shouldn't cause a second commit to happen.
     layer_tree_host()->SetNeedsCommit();
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, layer_tree_host()->SourceFrameNumber());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommitInsideLayout);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestSetNeedsCommitInsideLayout);
 
 class LayerTreeHostTestFrameOrdering : public LayerTreeHostTest {
  protected:
   enum MainOrder : int {
     MAIN_START = 1,
     MAIN_LAYOUT,
     MAIN_COMMIT_COMPLETE,
     MAIN_DID_BEGIN_FRAME,
     MAIN_END,
   };
@@ skipping 54 matching lines @@
 
   void AfterTest() override {
     EXPECT_TRUE(CheckStep(MAIN_END, &main_));
     EXPECT_TRUE(CheckStep(IMPL_END, &impl_));
   }
 
   MainOrder main_ = MAIN_START;
   ImplOrder impl_ = IMPL_START;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFrameOrdering);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestFrameOrdering);
 
 class LayerTreeHostTestSetNeedsUpdateInsideLayout : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void UpdateLayerTreeHost() override {
     // This shouldn't cause a second commit to happen.
     layer_tree_host()->SetNeedsUpdateLayers();
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, layer_tree_host()->SourceFrameNumber());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsUpdateInsideLayout);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestSetNeedsUpdateInsideLayout);
 
 // Test if the LTHI receives ReadyToActivate notifications from the TileManager
 // when no raster tasks get scheduled.
 class LayerTreeHostTestReadyToActivateEmpty : public LayerTreeHostTest {
  public:
   LayerTreeHostTestReadyToActivateEmpty()
       : did_notify_ready_to_activate_(false),
         all_tiles_required_for_activation_are_ready_to_draw_(false),
         required_for_activation_count_(0) {}
 
@@ skipping 23 matching lines @@
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
     EXPECT_EQ(size_t(0), required_for_activation_count_);
   }
 
  protected:
   bool did_notify_ready_to_activate_;
   bool all_tiles_required_for_activation_are_ready_to_draw_;
   size_t required_for_activation_count_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToActivateEmpty);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestReadyToActivateEmpty);
 
 // Test if the LTHI receives ReadyToActivate notifications from the TileManager
 // when some raster tasks flagged as REQUIRED_FOR_ACTIVATION got scheduled.
 class LayerTreeHostTestReadyToActivateNonEmpty
     : public LayerTreeHostTestReadyToActivateEmpty {
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
     EXPECT_LE(size_t(1), required_for_activation_count_);
   }
 
  private:
   FakeContentLayerClient client_;
 };
 
-// Multi-thread only because in single thread the commit goes directly to the
-// active tree, so notify ready to activate is skipped.
-MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToActivateNonEmpty);
+// No single thread test because the commit goes directly to the active tree in
+// single thread mode, so notify ready to activate is skipped.
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToActivateNonEmpty);
 
 // Test if the LTHI receives ReadyToDraw notifications from the TileManager when
 // no raster tasks get scheduled.
 class LayerTreeHostTestReadyToDrawEmpty : public LayerTreeHostTest {
  public:
   LayerTreeHostTestReadyToDrawEmpty()
       : did_notify_ready_to_draw_(false),
         all_tiles_required_for_draw_are_ready_to_draw_(false),
         required_for_draw_count_(0) {}
 
@@ skipping 19 matching lines @@
     EXPECT_TRUE(all_tiles_required_for_draw_are_ready_to_draw_);
     EXPECT_EQ(size_t(0), required_for_draw_count_);
   }
 
  protected:
   bool did_notify_ready_to_draw_;
   bool all_tiles_required_for_draw_are_ready_to_draw_;
   size_t required_for_draw_count_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToDrawEmpty);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestReadyToDrawEmpty);
 
 // Test if the LTHI receives ReadyToDraw notifications from the TileManager when
 // some raster tasks flagged as REQUIRED_FOR_DRAW got scheduled.
 class LayerTreeHostTestReadyToDrawNonEmpty
     : public LayerTreeHostTestReadyToDrawEmpty {
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
@@ skipping 86 matching lines @@
   FakeContentLayerClient client_;
   bool toggled_visibility_;
   bool did_notify_ready_to_draw_;
   bool did_draw_;
 };
 
 // Note: With this test setup, we only get tiles flagged as REQUIRED_FOR_DRAW in
 // single threaded mode.
 SINGLE_THREAD_TEST_F(LayerTreeHostTestReadyToDrawVisibility);
 
 class LayerTreeHostContextCacheTest : public LayerTreeHostTest {

[Khushal, 2016/10/14 20:12:31]

Can you add a comment on this saying that
"Since the LayerTreeHostContextCacheTests exclusively test the behavior of the
LayerTreeHostImpl, they don't need to run for the remote mode."

[xingliu, 2016/10/17 16:26:49]

Done.

  public:
   std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     // Create the main ContextProvider with a MockContextSupport.
     auto main_support = base::MakeUnique<MockContextSupport>();
     mock_main_context_support_ = main_support.get();
     auto test_main_context_provider = TestContextProvider::Create(
         TestWebGraphicsContext3D::Create(), std::move(main_support));
 
@@ skipping 199 matching lines @@
   void AfterTest() override {
     EXPECT_LE(1, num_commits_);
     EXPECT_LE(1, num_draws_);
   }
 
  private:
   int num_commits_;
   int num_draws_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit1);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestSetNeedsCommit1);
 
 // A SetNeedsCommit should lead to 1 commit. Issuing a second commit after that
 // first committed frame draws should lead to another commit.
 class LayerTreeHostTestSetNeedsCommit2 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit2() : num_commits_(0), num_draws_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override { ++num_draws_; }
@@ skipping 15 matching lines @@
   void AfterTest() override {
     EXPECT_EQ(2, num_commits_);
     EXPECT_LE(1, num_draws_);
   }
 
  private:
   int num_commits_;
   int num_draws_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
 
 // Verify that we pass property values in PushPropertiesTo.
 class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     layer_tree()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
@@ skipping 74 matching lines @@
         break;
       case DRAWS_CONTENT:
         layer->SetIsDrawable(true);
         break;
     }
   }
 
   int index_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesTo);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestPushPropertiesTo);
 
 class LayerTreeHostTestPushNodeOwnerToNodeIdMap : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     child_ = Layer::Create();
     root_->AddChild(child_);
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
@@ skipping 101 matching lines @@
     }
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
 };
 
+// The remote LTH doesn't build property tree, see if we need to
+// compare the property trees between LTH in process and impl side tree for
+// remote LTH test. See crbug/655795.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushNodeOwnerToNodeIdMap);

[Khushal, 2016/10/14 20:12:31]

Can you make the comment a bit more descriptive about what the problem is?

"This test compares the value of tree indexes from Layers on the engine to the
resulting PropertyTrees copied to the pending tree after the commit on the
client. This will result in a failure since while the client side Layers would
have the correct values for these indexes, the engine side Layers always hold
uninitialized indexes since PropertyTrees are never built on the engine. See
crbug.com/655795."

[xingliu, 2016/10/17 16:26:49]

Done.

 
 class LayerTreeHostTestSurfaceDamage : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     child_ = Layer::Create();
     grand_child_ = Layer::Create();
 
     layer_tree()->SetRootLayer(root_);
     root_->AddChild(child_);
@@ skipping 60 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
   scoped_refptr<Layer> grand_child_;
 };
 
+// Remote LTH test always re-sync tree hierachy, so render surface will always
+// be damaged, see crbug/605170.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSurfaceDamage);

[Khushal, 2016/10/14 20:12:31]

Again, a little more descriptive comment helps in addressing this later. :)

"This test changes properties on the Layer and ensures that the subtree damage
is tracked correctly on the resulting RenderSurfaceImpl for the corresponding
LayerImpl. Since the remote code path currently synchronizes the hierarchy
between the engine and client for every frame, all Layers on the client end up
being marked as damaged.
Enable this when crbug.com/605170 is fixed."

[xingliu, 2016/10/17 16:26:49]

Done.

 
 // Verify damage status of property trees is preserved after commit.
 class LayerTreeHostTestPropertyTreesChangedSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     child_ = Layer::Create();
     // This is to force the child to create a transform and effect node.
     child_->SetForceRenderSurfaceForTesting(true);
     root_->AddChild(child_);
@@ skipping 80 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   int index_;
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
 };
 
 SINGLE_THREAD_TEST_F(LayerTreeHostTestPropertyTreesChangedSync);

[Khushal, 2016/10/14 20:12:32]

+ajuma, is there a reason this is not enabled for mutli-thread mode?

[Khushal, 2016/10/18 00:59:06]

Also, ping on this one to Ali.

[ajuma, 2016/10/18 04:03:04]

No good reason that I can see. To make it work with multi-thread mode, I think
it should be enough to change CommitCompleteOnThread to use sync_tree rather
than active_tree.

 
 class LayerTreeHostTestEffectTreeSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     layer_tree()->SetRootLayer(root_);
     blur_filter_.Append(FilterOperation::CreateBlurFilter(0.5f));
     brightness_filter_.Append(FilterOperation::CreateBrightnessFilter(0.25f));
     sepia_filter_.Append(FilterOperation::CreateSepiaFilter(0.75f));
     LayerTreeHostTest::SetupTree();
@@ skipping 89 matching lines @@
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> root_;
   FilterOperations blur_filter_;
   FilterOperations brightness_filter_;
   FilterOperations sepia_filter_;
 };
 
+// Remote LTH won't work because it doesn't build property tree. See
+// crbug/655795.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestEffectTreeSync);

[Khushal, 2016/10/14 20:12:32]

Update the comment,
"This test verifies that correct values are retained on the impl thread in cases
where they are animated on that thread. Since remote mode doesn't support
threaded animations, we don't need to run this in remote mode."

Same comment for TransformTreeSync.

 
 class LayerTreeHostTestTransformTreeSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 56 matching lines @@
         EndTest();
     }
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> root_;
 };
 
+// Remote LTH won't work because it doesn't build property tree. See
+// crbug/655795.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestTransformTreeSync);
 
 // Verify damage status is updated even when the transform tree doesn't need
 // to be updated at draw time.
 class LayerTreeHostTestTransformTreeDamageIsUpdated : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_ = Layer::Create();
     child_ = Layer::Create();
     grand_child_ = Layer::Create();
@@ skipping 54 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
   scoped_refptr<Layer> grand_child_;
 };
 
+// LTH remote test is not needed since we don't do animation.

[Khushal, 2016/10/14 20:12:31]

And here.

 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestTransformTreeDamageIsUpdated);
 
 // Test that when mask layers switches layers, this gets pushed onto impl.
 // Also test that mask layer is in the layer update list even if its owning
 // layer isn't.
 class LayerTreeHostTestSwitchMaskLayer : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
@@ skipping 50 matching lines @@
         break;
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<Layer> mask_layer;
   int index_;
 };
 
+// Remote LTH won't work because we update all layers in BeginMainFrame, some
+// layers are not pushed into the update list in LTH in process.
+// see crbug.com/650885.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSwitchMaskLayer);

[Khushal, 2016/10/14 20:12:32]

"This test also verifies that the Layers updated in a main frame correspond only
to the Layers that need updates computed using
draw_property_utils::FindLayersThatNeedUpdates. Since LayerTreeHostRemote
currently updates all Layers during the main frame, the test fails for remote
mode.
TODO(xingliu): Revisit enabling this when crbug.com/650885 is resolved."

[xingliu, 2016/10/17 16:26:49]

Done.

 
 // 1 setNeedsRedraw after the first commit has completed should lead to 1
 // additional draw.
 class LayerTreeHostTestSetNeedsRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedraw() : num_commits_(0), num_draws_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 15 matching lines @@
   void AfterTest() override {
     EXPECT_GE(2, num_draws_);
     EXPECT_EQ(1, num_commits_);
   }
 
  private:
   int num_commits_;
   int num_draws_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedraw);
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedraw);
 
 // After setNeedsRedrawRect(invalid_rect) the final damage_rect
 // must contain invalid_rect.
 class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedrawRect()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     root_layer_ = FakePictureLayer::Create(&client_);
@@ skipping 37 matching lines @@
   void AfterTest() override { EXPECT_EQ(2, num_draws_); }
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedrawRect);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestSetNeedsRedrawRect);
 
 // Ensure the texture size of the pending and active trees are identical when a
 // layer is not in the viewport and a resize happens on the viewport
 class LayerTreeHostTestGpuRasterDeviceSizeChanged : public LayerTreeHostTest {
  public:
   LayerTreeHostTestGpuRasterDeviceSizeChanged()
       : num_draws_(0), bounds_(500, 64), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
@@ skipping 5480 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSubmitFrameResources);
 
 }  // namespace
 }  // namespace cc