Enable more layer_tree_host_unittest for LayerTreeHostRemote.

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 269 matching lines @@
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
     EXPECT_LE(size_t(1), required_for_activation_count_);
   }
 
  private:
   FakeContentLayerClient client_;
 };
 
 // No single thread test because the commit goes directly to the active tree in
 // single thread mode, so notify ready to activate is skipped.
-// No remote test because we currently don't deserialize FakePictureLayer,
-// so on the impl side, PictureLayerImpl is created instead of
-// FakePictureLayerImpl, see crbug/657871.
-MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToActivateNonEmpty);
+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 1313 matching lines @@
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
 };
 
 // As there's no pending tree in single-threaded case, this test should run
 // only for multi-threaded case.
-MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterDeviceSizeChanged);
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterDeviceSizeChanged);
 
 class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
@@ skipping 29 matching lines @@
   void AfterTest() override {
     EXPECT_EQ(gfx::Size(4, 4).ToString(), scaled_layer_->bounds().ToString());
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> scaled_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoExtraCommitFromInvalidate);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestNoExtraCommitFromInvalidate);
 
 class LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate
     : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetupTree() override {
     root_layer_ = Layer::Create();
@@ skipping 36 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_;
 };
 
+// No remote test here because PaintedScrollbarLayer is not supported by LTH
+// remote.
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate);
 
 class LayerTreeHostTestDeviceScaleFactorChange : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetupTree() override {
@@ skipping 47 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> child_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorChange);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestDeviceScaleFactorChange);
 
 class LayerTreeHostTestDeviceColorSpaceChange : public LayerTreeHostTest {
  public:
   void SetupTree() override {
     space1_ = gfx::ColorSpace::CreateXYZD50();
     space2_ = gfx::ColorSpace::CreateSRGB();
 
     root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
@@ skipping 102 matching lines @@
   void AfterTest() override {}
 
  private:
   gfx::ColorSpace space1_;
   gfx::ColorSpace space2_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> child_layer_;
 };
 
+// No remote test because LTH remote doesn't serialize device_color_space, so
+// LTH in process will always use the default color space here.
+// see crbug/658786.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceColorSpaceChange);
 
 class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNextCommitForcesRedraw()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
@@ skipping 70 matching lines @@
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
 };
 
 // This test blocks activation which is not supported for single thread mode.
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
+REMOTE_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
 
 // Tests that if a layer is not drawn because of some reason in the parent then
 // its damage is preserved until the next time it is drawn.
 class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     // If we don't set the minimum contents scale, it's harder to verify whether
     // the damage we get is correct. For other scale amounts, please see
     // LayerTreeHostTestDamageWithScale.
     settings->minimum_contents_scale = 1.f;
@@ skipping 76 matching lines @@
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
   scoped_refptr<FakePictureLayer> parent_layer_;
   scoped_refptr<FakePictureLayer> child_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestUndrawnLayersDamageLater);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestUndrawnLayersDamageLater);
 
 // Tests that if a layer is not drawn because of some reason in the parent then
 // its damage is preserved until the next time it is drawn.
 class LayerTreeHostTestDamageWithScale : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDamageWithScale() {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
@@ skipping 84 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> child_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDamageWithScale);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestDamageWithScale);
 
 // This test verifies that properties on the layer tree host are commited
 // to the impl side.
 class LayerTreeHostTestCommit : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCommit() {}
 
   void BeginTest() override {
     layer_tree()->SetViewportSize(gfx::Size(20, 20));
     layer_tree()->set_background_color(SK_ColorGRAY);
@@ skipping 23 matching lines @@
               impl->active_tree()->event_listener_properties(
                   EventListenerClass::kTouchEndOrCancel));
     EXPECT_TRUE(impl->active_tree()->have_scroll_event_handlers());
 
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it doesn't draw due to tree
 // activation failure.
 class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimeUpdatesAfterActivationFails()
       : frame_count_with_pending_tree_(0) {}
 
@@ skipping 37 matching lines @@
   void AfterTest() override {}
 
  private:
   int frame_count_with_pending_tree_;
   base::TimeTicks first_frame_time_;
 };
 
 // This test blocks activation which is not supported for single thread mode.
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(
     LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
+REMOTE_TEST_F(LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it draws in each frame.
 class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimeUpdatesAfterDraw() : frame_(0) {}
 
   void BeginTest() override {
     layer_tree()->SetViewportSize(gfx::Size(20, 20));
     layer_tree()->set_background_color(SK_ColorGRAY);
@@ skipping 28 matching lines @@
       EXPECT_EQ(0, frame_);
   }
 
   void AfterTest() override {}
 
  private:
   int frame_;
   base::TimeTicks first_frame_time_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFrameTimeUpdatesAfterDraw);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestFrameTimeUpdatesAfterDraw);
 
 // Verifies that StartPageScaleAnimation events propagate correctly
 // from LayerTreeHost to LayerTreeHostImpl in the MT compositor.
 class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
  public:
   LayerTreeHostTestStartPageScaleAnimation() {}
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
@@ skipping 57 matching lines @@
     }
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> scroll_layer_;
 };
 
 // Single thread proxy does not support impl-side page scale changes.
+// Remote test does not support page scale animation.
 MULTI_THREAD_TEST_F(LayerTreeHostTestStartPageScaleAnimation);
 
 class LayerTreeHostTestSetVisible : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetVisible() : num_draws_(0) {}
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
@@ skipping 10 matching lines @@
     ++num_draws_;
     EndTest();
   }
 
   void AfterTest() override { EXPECT_EQ(1, num_draws_); }
 
  private:
   int num_draws_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestSetVisible);
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetVisible);
 
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers() {}
 
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
     root_layer_ = FakePictureLayer::Create(&client_);
     child_layer_ = FakePictureLayer::Create(&client_);
@@ skipping 81 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
   scoped_refptr<FakePictureLayer> child_layer_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);
+REMOTE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);
 
 class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   void BeginTest() override {
     layer_tree()->SetViewportSize(gfx::Size(10, 10));
     layer_tree()->root_layer()->SetBounds(gfx::Size(10, 10));
 
@@ skipping 29 matching lines @@
     EXPECT_EQ(1, num_commit_complete_);
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> layer_;
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousInvalidate);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestContinuousInvalidate);
 
 class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeferCommits()
       : num_will_begin_impl_frame_(0), num_send_begin_main_frame_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
                                   const BeginFrameArgs& args) override {
@@ skipping 37 matching lines @@
   void AfterTest() override {
     EXPECT_GE(num_will_begin_impl_frame_, 5);
     EXPECT_EQ(2, num_send_begin_main_frame_);
   }
 
  private:
   int num_will_begin_impl_frame_;
   int num_send_begin_main_frame_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestDeferCommits);
 
 class LayerTreeHostTestCompositeImmediatelyStateTransitions
     : public LayerTreeHostTest {
  public:
   enum {
     kInvalid,
     kStartedTest,
     kStartedImplFrame,
     kStartedMainFrame,
     kStartedCommit,
@@ skipping 138 matching lines @@
     }
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   int num_tiles_rastered_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLCDChange);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestLCDChange);
 
 class LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled
     : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->using_synchronous_renderer_compositor = true;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // The BeginFrame notification is turned off now but will get enabled
     // once we return. End test while it's enabled.
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostTest::EndTest, base::Unretained(this)));
   }
 
   void AfterTest() override {}
 };
 
+// No remote test since synchronous renderer compositor is not supported for LTH
+// remote.
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled);
 
 class LayerTreeHostTestAbortedCommitDoesntStall : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestAbortedCommitDoesntStall()
       : commit_count_(0), commit_abort_count_(0), commit_complete_count_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 104 matching lines @@
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE, base::Bind(&OnDrawCompositorFrameSink::OnDraw,
                                 base::Unretained(compositor_frame_sink_),
                                 resourceless_software_draw));
     }
   }
 
   OnDrawCompositorFrameSink* compositor_frame_sink_ = nullptr;
 };
 
+// No remote test since synchronous renderer compositor is not supported for LTH
+// remote.
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor);
 
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
     layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
     layer->SetBounds(gfx::Size(10, 10));
     layer_tree()->root_layer()->AddChild(layer);
     client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
+SINGLE_MULTI_AND_REMOTE_TEST_F(
     LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation);
 
 class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
  public:
   void BeginTest() override {
     frame_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   // Round 1: commit + draw
@@ skipping 28 matching lines @@
         break;
     }
   }
 
   void AfterTest() override {}
 
  protected:
   int frame_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNumFramesPending);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestNumFramesPending);
 
 class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->using_synchronous_renderer_compositor = true;
   }
 
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
@@ skipping 85 matching lines @@
  private:
   OnDrawCompositorFrameSink* compositor_frame_sink_ = nullptr;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<Layer> child_layer_;
   int draw_count_ = 0;
 };
 
 // Resourceless is not used for SingleThreadProxy, so it is unimplemented.
+// No remote test since synchronous renderer compositor is not supported for LTH
+// remote.
 MULTI_THREAD_TEST_F(LayerTreeHostTestResourcelessSoftwareDraw);
 
 // Test for UI Resource management.
 class LayerTreeHostTestUIResource : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->renderer_settings.texture_id_allocation_chunk_size = 1;
   }
@@ skipping 76 matching lines @@
 
   void CreateResource() {
     ui_resources_[num_ui_resources_++] =
         FakeScopedUIResource::Create(layer_tree_host()->GetUIResourceManager());
   }
 
   std::unique_ptr<FakeScopedUIResource> ui_resources_[5];
   int num_ui_resources_;
 };
 
+// No remote test since LTH remote does not support UIResourceLayers and
+// PaintedScrollbarLayers, which uses UIResourceManager.
 MULTI_THREAD_TEST_F(LayerTreeHostTestUIResource);
 
 class PushPropertiesCountingLayerImpl : public LayerImpl {
  public:
   static std::unique_ptr<PushPropertiesCountingLayerImpl> Create(
       LayerTreeImpl* tree_impl,
       int id) {
     return base::WrapUnique(new PushPropertiesCountingLayerImpl(tree_impl, id));
   }
 
@@ skipping 17 matching lines @@
 
  private:
   size_t push_properties_count_;
 
   PushPropertiesCountingLayerImpl(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id), push_properties_count_(0) {
     SetBounds(gfx::Size(1, 1));
   }
 };
 
 class PushPropertiesCountingLayer : public Layer {

[Khushal, 2016/10/27 18:37:52]

The tests which use this would definitely be nice to have. Because the code on
the engine side does rely on Layers that need push properties to decide what is
going to be serialized.

The ToLayerPropertiesProto method is almost the equivalent of PushPropertiesTo
for pushing into a proto. May be we could add this layer as a type for
serialization, like the fake picture layer, but do what we do in
PushPropertiesTo in ToLayerPropertiesProto also. It's fine to do in both, since
only one of them should ever run, and it will create the correct runtime
LayerImpl on the client side.

+ajuma, wdyt?

[ajuma, 2016/10/27 19:40:03]

That sounds like a good plan.

  public:
   static scoped_refptr<PushPropertiesCountingLayer> Create() {
     return new PushPropertiesCountingLayer();
   }
 
   void PushPropertiesTo(LayerImpl* layer) override {
     Layer::PushPropertiesTo(layer);
     push_properties_count_++;
     if (persist_needs_push_properties_) {
       GetLayerTree()->AddLayerShouldPushProperties(this);
@@ skipping 221 matching lines @@
   scoped_refptr<PushPropertiesCountingLayer> other_root_;
   scoped_refptr<PushPropertiesCountingLayer> leaf_always_pushing_layer_;
   size_t expected_push_properties_root_;
   size_t expected_push_properties_child_;
   size_t expected_push_properties_child2_;
   size_t expected_push_properties_grandchild_;
   size_t expected_push_properties_other_root_;
   size_t expected_push_properties_leaf_layer_;
 };
 
+// No remote test because LTH remote serializes the layers that needs to push
+// property into protos, but does not directly call PushPropertiesTo to sync
+// states to the impl side. See crbug/658913.
 MULTI_THREAD_TEST_F(LayerTreeHostTestLayersPushProperties);
 
 class LayerTreeHostTestImplLayersPushProperties
     : public LayerTreeHostTestLayersPushProperties {
  protected:
   void BeginTest() override {
     expected_push_properties_root_impl_ = 0;
     expected_push_properties_child_impl_ = 0;
     expected_push_properties_grandchild_impl_ = 0;
     expected_push_properties_child2_impl_ = 0;
@@ skipping 177 matching lines @@
   }
 
   size_t expected_push_properties_root_impl_;
   size_t expected_push_properties_child_impl_;
   size_t expected_push_properties_child2_impl_;
   size_t expected_push_properties_grandchild_impl_;
   size_t expected_push_properties_grandchild2_impl_;
 };
 
 // In single thread there's no pending tree to push properties from.
+// No remote test because LTH remote serializes the layers that needs to push
+// property into protos, but does not directly call PushPropertiesTo to sync
+// states to the impl side. See crbug/658913.
 MULTI_THREAD_TEST_F(LayerTreeHostTestImplLayersPushProperties);
 
 class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(1, 1));
@@ skipping 37 matching lines @@
         break;
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<Layer> root_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer_;
 };
 
+// No remote test since remote LTH does not support PaintedScrollbarLayer.
 MULTI_THREAD_TEST_F(LayerTreeHostTestPropertyChangesDuringUpdateArePushed);
 
 class LayerTreeHostTestSetDrawableCausesCommit : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     root_ = PushPropertiesCountingLayer::Create();
     child_ = PushPropertiesCountingLayer::Create();
     root_->AddChild(child_);
@@ skipping 40 matching lines @@
         break;
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<PushPropertiesCountingLayer> root_;
   scoped_refptr<PushPropertiesCountingLayer> child_;
 };
 
+// No remote test because LTH remote serializes the layers that needs to push
+// property into protos, but does not directly call PushPropertiesTo to sync
+// states to the impl side. See crbug/658913.
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetDrawableCausesCommit);
 
 class LayerTreeHostTestCasePushPropertiesThreeGrandChildren
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override {
     expected_push_properties_root_ = 0;
     expected_push_properties_child_ = 0;
     expected_push_properties_grandchild1_ = 0;
     expected_push_properties_grandchild2_ = 0;
@@ skipping 53 matching lines @@
         EXPECT_TRUE(layer_tree()->LayerNeedsPushPropertiesForTesting(
             grandchild3_.get()));
         break;
       case 1:
         EndTest();
         break;
     }
   }
 };
 
+// No remote test because LTH remote serializes the layers that needs to push
+// property into protos, but does not directly call PushPropertiesTo to sync
+// states to the impl side. See crbug/658913.
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree()->SetRootLayer(root_);
@@ skipping 63 matching lines @@
         EXPECT_FALSE(
             layer_tree()->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree()->LayerNeedsPushPropertiesForTesting(child_.get()));
         EndTest();
         break;
     }
   }
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion);
+REMOTE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree->SetRootLayer(root_);
@@ skipping 27 matching lines @@
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
         EndTest();
         break;
     }
   }
 };
 
+// No remote test because persist_needs_push_properties_ is used in
+// PushPropertiesTo, and LTH remote does not directly call PushPropertiesTo to
+// synchronize states to the impl side. See crbug/658913.
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence);
 
 class LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
@@ skipping 49 matching lines @@
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
         EXPECT_TRUE(
             layer_tree->LayerNeedsPushPropertiesForTesting(child_.get()));
 
         EndTest();
         break;
     }
   }
 };
 
-MULTI_THREAD_TEST_F(
+REMOTE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ skipping 44 matching lines @@
 
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
 
         EndTest();
         break;
     }
   }
 };
 
-MULTI_THREAD_TEST_F(
+REMOTE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
   void DidCommitAndDrawFrame() override {
     LayerTree* layer_tree = layer_tree_host()->GetLayerTree();
     int last_source_frame_number = layer_tree_host()->SourceFrameNumber() - 1;
     switch (last_source_frame_number) {
       case 0:
@@ skipping 44 matching lines @@
 
         EXPECT_FALSE(
             layer_tree->LayerNeedsPushPropertiesForTesting(root_.get()));
 
         EndTest();
         break;
     }
   }
 };
 
-MULTI_THREAD_TEST_F(
+REMOTE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent);
 
 // This test verifies that the tree activation callback is invoked correctly.
 class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
  public:
   LayerTreeHostTestTreeActivationCallback()
       : num_commits_(0), callback_count_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 38 matching lines @@
                   base::Unretained(this))
             : base::Closure());
   }
 
   void ActivationCallback() { ++callback_count_; }
 
   int num_commits_;
   int callback_count_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestTreeActivationCallback);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestTreeActivationCallback);
 
 class LayerInvalidateCausesDraw : public LayerTreeHostTest {
  public:
   LayerInvalidateCausesDraw() : num_commits_(0), num_draws_(0) {}
 
   void BeginTest() override {
     ASSERT_TRUE(invalidate_layer_)
         << "Derived tests must set this in SetupTree";
 
     // One initial commit.
@@ skipping 42 matching lines @@
     video_layer->SetIsDrawable(true);
     layer_tree()->root_layer()->AddChild(video_layer);
 
     invalidate_layer_ = video_layer;
   }
 
  private:
   FakeVideoFrameProvider provider_;
 };
 
+// LTH remote does not support VideoLayer.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestVideoLayerInvalidate);
 
 class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_layer_ = Layer::Create();
     root_layer_->SetPosition(gfx::PointF());
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     parent_layer_ = SolidColorLayer::Create();
@@ skipping 47 matching lines @@
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<SolidColorLayer> parent_layer_;
   scoped_refptr<SolidColorLayer> child_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
+SINGLE_MULTI_AND_REMOTE_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     layer_tree()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
@@ skipping 12 matching lines @@
     EXPECT_GT(root_layer_->update_count(), 0);
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_layer_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestUpdateLayerInEmptyViewport);
+REMOTE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestUpdateLayerInEmptyViewport);
 
 class LayerTreeHostTestElasticOverscroll : public LayerTreeHostTest {
  public:
   LayerTreeHostTestElasticOverscroll()
       : scroll_elasticity_helper_(nullptr), num_draws_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->enable_elastic_overscroll = true;
   }
 
@@ skipping 74 matching lines @@
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   ScrollElasticityHelper* scroll_elasticity_helper_;
   int content_layer_id_;
   int num_draws_;
 };
 
+// Remote test does not support enable_elastic_overscroll.
 MULTI_THREAD_TEST_F(LayerTreeHostTestElasticOverscroll);
 
 struct TestSwapPromiseResult {
   TestSwapPromiseResult()
       : did_activate_called(false),
         did_swap_called(false),
         did_not_swap_called(false),
         dtor_called(false),
         reason(SwapPromise::COMMIT_FAILS) {}
 
@@ skipping 84 matching lines @@
     // The pinned active swap promise should not activate, but should swap.
     EXPECT_FALSE(pinned_active_swap_promise_result_.did_activate_called);
     EXPECT_TRUE(pinned_active_swap_promise_result_.did_swap_called);
   }
 
   TestSwapPromiseResult pending_swap_promise_result_;
   TestSwapPromiseResult active_swap_promise_result_;
   TestSwapPromiseResult pinned_active_swap_promise_result_;
 };
 
+// No remote test because this test compares the swap promises result between
+// LTH in process and LTH impl. LTH remote runs its own swap promise, and we
+// don't send swap promises to the client.
 MULTI_THREAD_TEST_F(PinnedLayerTreeSwapPromise);
 
 class LayerTreeHostTestBreakSwapPromise : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestBreakSwapPromise()
       : commit_count_(0), commit_complete_count_(0) {}
 
   void WillBeginMainFrame() override {
     ASSERT_LE(commit_count_, 2);
     std::unique_ptr<SwapPromise> swap_promise(
@@ skipping 77 matching lines @@
       EXPECT_EQ(SwapPromise::SWAP_FAILS, swap_promise_result_[2].reason);
       EXPECT_TRUE(swap_promise_result_[2].dtor_called);
     }
   }
 
   int commit_count_;
   int commit_complete_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
+// No remote test because LTH remote runs its own swap promises, and we
+// don't send swap promises to the LTH in process on the client side.
 MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 
 class LayerTreeHostTestKeepSwapPromise : public LayerTreeHostTest {
  public:
   LayerTreeHostTestKeepSwapPromise() {}
 
   void BeginTest() override {
     layer_ = SolidColorLayer::Create();
     layer_->SetIsDrawable(true);
     layer_->SetBounds(gfx::Size(10, 10));
@@ skipping 71 matching lines @@
   }
 
   void AfterTest() override {}
 
  private:
   int num_swaps_ = 0;
   scoped_refptr<Layer> layer_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
+// No remote test because LTH remote runs its own swap promises, and we
+// don't send swap promises to the LTH in process on the client side.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromise);
 
 class LayerTreeHostTestKeepSwapPromiseMFBA : public LayerTreeHostTest {
  public:
   LayerTreeHostTestKeepSwapPromiseMFBA() {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->main_frame_before_activation_enabled = true;
   }
 
@@ skipping 94 matching lines @@
   }
 
   void AfterTest() override { EXPECT_EQ(1, num_swaps_); }
 
  private:
   int num_swaps_ = 0;
   scoped_refptr<Layer> layer_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
+// No remote test because LTH remote runs its own swap promises, and we
+// don't send swap promises to the LTH in process on the client side.
 MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromiseMFBA);
 
 class LayerTreeHostTestBreakSwapPromiseForVisibility
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetVisibleFalseAndQueueSwapPromise() {
     layer_tree_host()->SetVisible(false);
     std::unique_ptr<SwapPromise> swap_promise(
@@ skipping 22 matching lines @@
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
   TestSwapPromiseResult swap_promise_result_;
 };
 
+// No remote test because LTH remote runs its own swap promises, and we
+// don't send swap promises to the LTH in process on the client side.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForVisibility);
 
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
                            int* set_needs_redraw_count)
       : SwapPromiseMonitor(
             (layer_tree_host ? layer_tree_host->GetSwapPromiseManager()
@@ skipping 63 matching lines @@
       EXPECT_EQ(3, set_needs_commit_count);
       EXPECT_EQ(0, set_needs_redraw_count);
     }
 
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
+// No remote test because LTH remote runs its own swap promises, and we
+// don't send swap promises to the LTH in process on the client side.
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     ui_resource_ =
         FakeScopedUIResource::Create(layer_tree_host()->GetUIResourceManager());
     client_.set_bounds(layer_tree()->root_layer()->bounds());
@@ skipping 201 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
   FakePictureLayer* layer_;
   FakeRecordingSource* recording_source_;
 };
 
+// No remote test since we does not send gpu rasterization flag to the client.
+// See crbug/650431.
 MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationEnabled);
 
 class LayerTreeHostTestGpuRasterizationReenabled : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     EXPECT_FALSE(settings->gpu_rasterization_enabled);
     settings->gpu_rasterization_enabled = true;
   }
 
   void SetupTree() override {
@@ skipping 1695 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSubmitFrameResources);
 
 }  // namespace
 }  // namespace cc