| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/blimp/layer_tree_host_remote.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/run_loop.h" | |
| 9 #include "base/threading/thread_task_runner_handle.h" | |
| 10 #include "cc/animation/animation_host.h" | |
| 11 #include "cc/layers/layer.h" | |
| 12 #include "cc/output/begin_frame_args.h" | |
| 13 #include "cc/test/fake_remote_compositor_bridge.h" | |
| 14 #include "cc/test/stub_layer_tree_host_client.h" | |
| 15 #include "cc/trees/layer_tree_settings.h" | |
| 16 #include "testing/gmock/include/gmock/gmock.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 using ::testing::_; | |
| 20 using testing::InSequence; | |
| 21 using testing::Mock; | |
| 22 using testing::StrictMock; | |
| 23 | |
| 24 #define EXPECT_BEGIN_MAIN_FRAME(client, num) \ | |
| 25 EXPECT_CALL(client, WillBeginMainFrame()).Times(num); \ | |
| 26 EXPECT_CALL(client, BeginMainFrame(_)).Times(num); \ | |
| 27 EXPECT_CALL(client, DidUpdateLayerTreeHost()).Times(num); \ | |
| 28 EXPECT_CALL(client, WillCommit()).Times(num); \ | |
| 29 EXPECT_CALL(client, DidCommit()).Times(num); \ | |
| 30 EXPECT_CALL(client, DidBeginMainFrame()).Times(num); | |
| 31 | |
| 32 #define EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(client, num) \ | |
| 33 EXPECT_BEGIN_MAIN_FRAME(client, num) \ | |
| 34 EXPECT_CALL(client, DidCommitAndDrawFrame()).Times(num); \ | |
| 35 EXPECT_CALL(client, DidCompleteSwapBuffers()).Times(num); | |
| 36 | |
| 37 namespace cc { | |
| 38 namespace { | |
| 39 | |
| 40 class UpdateTrackingRemoteCompositorBridge : public FakeRemoteCompositorBridge { | |
| 41 public: | |
| 42 UpdateTrackingRemoteCompositorBridge( | |
| 43 scoped_refptr<base::SingleThreadTaskRunner> compositor_main_task_runner) | |
| 44 : FakeRemoteCompositorBridge(std::move(compositor_main_task_runner)) {} | |
| 45 | |
| 46 ~UpdateTrackingRemoteCompositorBridge() override = default; | |
| 47 | |
| 48 void ProcessCompositorStateUpdate( | |
| 49 std::unique_ptr<CompositorProtoState> compositor_proto_state) override { | |
| 50 num_updates_received_++; | |
| 51 }; | |
| 52 | |
| 53 int num_updates_received() const { return num_updates_received_; } | |
| 54 | |
| 55 private: | |
| 56 int num_updates_received_ = 0; | |
| 57 }; | |
| 58 | |
| 59 class MockLayerTreeHostClient : public StubLayerTreeHostClient { | |
| 60 public: | |
| 61 MockLayerTreeHostClient() = default; | |
| 62 ~MockLayerTreeHostClient() override = default; | |
| 63 | |
| 64 void set_update_host_callback(base::Closure callback) { | |
| 65 update_host_callback_ = callback; | |
| 66 } | |
| 67 | |
| 68 void UpdateLayerTreeHost() override { | |
| 69 update_host_callback_.Run(); | |
| 70 DidUpdateLayerTreeHost(); | |
| 71 } | |
| 72 | |
| 73 // LayerTreeHostClient implementation. | |
| 74 MOCK_METHOD0(WillBeginMainFrame, void()); | |
| 75 MOCK_METHOD1(BeginMainFrame, void(const BeginFrameArgs& args)); | |
| 76 MOCK_METHOD0(DidBeginMainFrame, void()); | |
| 77 MOCK_METHOD0(DidUpdateLayerTreeHost, void()); | |
| 78 MOCK_METHOD0(WillCommit, void()); | |
| 79 MOCK_METHOD0(DidCommit, void()); | |
| 80 MOCK_METHOD0(DidCommitAndDrawFrame, void()); | |
| 81 MOCK_METHOD0(DidCompleteSwapBuffers, void()); | |
| 82 | |
| 83 private: | |
| 84 base::Closure update_host_callback_; | |
| 85 }; | |
| 86 | |
| 87 class MockLayer : public Layer { | |
| 88 public: | |
| 89 explicit MockLayer(bool update) : update_(update) {} | |
| 90 | |
| 91 bool Update() override { | |
| 92 did_update_ = true; | |
| 93 return update_; | |
| 94 } | |
| 95 | |
| 96 bool did_update() const { return did_update_; } | |
| 97 | |
| 98 private: | |
| 99 ~MockLayer() override {} | |
| 100 | |
| 101 bool update_; | |
| 102 bool did_update_ = false; | |
| 103 }; | |
| 104 | |
| 105 class MockLayerTree : public LayerTree { | |
| 106 public: | |
| 107 MockLayerTree(std::unique_ptr<AnimationHost> animation_host, | |
| 108 LayerTreeHost* layer_tree_host) | |
| 109 : LayerTree(std::move(animation_host), layer_tree_host) {} | |
| 110 ~MockLayerTree() override {} | |
| 111 | |
| 112 // We don't want tree sync requests to trigger commits. | |
| 113 void SetNeedsFullTreeSync() override {} | |
| 114 }; | |
| 115 | |
| 116 class LayerTreeHostRemoteForTesting : public LayerTreeHostRemote { | |
| 117 public: | |
| 118 explicit LayerTreeHostRemoteForTesting(InitParams* params) | |
| 119 : LayerTreeHostRemote( | |
| 120 params, | |
| 121 base::MakeUnique<MockLayerTree>(AnimationHost::CreateMainInstance(), | |
| 122 this)) {} | |
| 123 ~LayerTreeHostRemoteForTesting() override {} | |
| 124 }; | |
| 125 | |
| 126 class LayerTreeHostRemoteTest : public testing::Test { | |
| 127 public: | |
| 128 LayerTreeHostRemoteTest() { | |
| 129 mock_layer_tree_host_client_.set_update_host_callback(base::Bind( | |
| 130 &LayerTreeHostRemoteTest::UpdateLayerTreeHost, base::Unretained(this))); | |
| 131 } | |
| 132 ~LayerTreeHostRemoteTest() override {} | |
| 133 | |
| 134 void SetUp() override { | |
| 135 LayerTreeHostRemote::InitParams params; | |
| 136 params.client = &mock_layer_tree_host_client_; | |
| 137 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner = | |
| 138 base::ThreadTaskRunnerHandle::Get(); | |
| 139 params.main_task_runner = main_task_runner; | |
| 140 std::unique_ptr<UpdateTrackingRemoteCompositorBridge> | |
| 141 remote_compositor_bridge = | |
| 142 base::MakeUnique<UpdateTrackingRemoteCompositorBridge>( | |
| 143 main_task_runner); | |
| 144 remote_compositor_bridge_ = remote_compositor_bridge.get(); | |
| 145 params.remote_compositor_bridge = std::move(remote_compositor_bridge); | |
| 146 LayerTreeSettings settings; | |
| 147 params.settings = &settings; | |
| 148 | |
| 149 layer_tree_host_ = base::MakeUnique<LayerTreeHostRemoteForTesting>(¶ms); | |
| 150 root_layer_ = make_scoped_refptr(new MockLayer(false)); | |
| 151 layer_tree_host_->GetLayerTree()->SetRootLayer(root_layer_); | |
| 152 } | |
| 153 | |
| 154 void TearDown() override { | |
| 155 Mock::VerifyAndClearExpectations(&mock_layer_tree_host_client_); | |
| 156 layer_tree_host_ = nullptr; | |
| 157 root_layer_ = nullptr; | |
| 158 remote_compositor_bridge_ = nullptr; | |
| 159 } | |
| 160 | |
| 161 void UpdateLayerTreeHost() { | |
| 162 if (needs_animate_during_main_frame_) { | |
| 163 layer_tree_host_->SetNeedsAnimate(); | |
| 164 needs_animate_during_main_frame_ = false; | |
| 165 } | |
| 166 | |
| 167 if (needs_commit_during_main_frame_) { | |
| 168 layer_tree_host_->SetNeedsCommit(); | |
| 169 needs_commit_during_main_frame_ = false; | |
| 170 } | |
| 171 } | |
| 172 | |
| 173 void set_needs_animate_during_main_frame(bool needs) { | |
| 174 needs_animate_during_main_frame_ = needs; | |
| 175 } | |
| 176 | |
| 177 void set_needs_commit_during_main_frame(bool needs) { | |
| 178 needs_commit_during_main_frame_ = needs; | |
| 179 } | |
| 180 | |
| 181 protected: | |
| 182 std::unique_ptr<LayerTreeHostRemote> layer_tree_host_; | |
| 183 StrictMock<MockLayerTreeHostClient> mock_layer_tree_host_client_; | |
| 184 UpdateTrackingRemoteCompositorBridge* remote_compositor_bridge_ = nullptr; | |
| 185 scoped_refptr<MockLayer> root_layer_; | |
| 186 | |
| 187 bool needs_animate_during_main_frame_ = false; | |
| 188 bool needs_commit_during_main_frame_ = false; | |
| 189 | |
| 190 private: | |
| 191 DISALLOW_COPY_AND_ASSIGN(LayerTreeHostRemoteTest); | |
| 192 }; | |
| 193 | |
| 194 TEST_F(LayerTreeHostRemoteTest, BeginMainFrameAnimateOnly) { | |
| 195 // The main frame should run until the animate step only. | |
| 196 InSequence s; | |
| 197 int num_of_frames = 1; | |
| 198 EXPECT_BEGIN_MAIN_FRAME(mock_layer_tree_host_client_, num_of_frames); | |
| 199 | |
| 200 int previous_source_frame = layer_tree_host_->SourceFrameNumber(); | |
| 201 layer_tree_host_->SetNeedsAnimate(); | |
| 202 | |
| 203 base::RunLoop().RunUntilIdle(); | |
| 204 EXPECT_FALSE(root_layer_->did_update()); | |
| 205 EXPECT_EQ(0, remote_compositor_bridge_->num_updates_received()); | |
| 206 EXPECT_EQ(++previous_source_frame, layer_tree_host_->SourceFrameNumber()); | |
| 207 } | |
| 208 | |
| 209 TEST_F(LayerTreeHostRemoteTest, BeginMainFrameUpdateLayers) { | |
| 210 // The main frame should run until the update layers step only. | |
| 211 InSequence s; | |
| 212 int num_of_frames = 1; | |
| 213 EXPECT_BEGIN_MAIN_FRAME(mock_layer_tree_host_client_, num_of_frames); | |
| 214 | |
| 215 int previous_source_frame = layer_tree_host_->SourceFrameNumber(); | |
| 216 layer_tree_host_->SetNeedsUpdateLayers(); | |
| 217 | |
| 218 base::RunLoop().RunUntilIdle(); | |
| 219 EXPECT_TRUE(root_layer_->did_update()); | |
| 220 EXPECT_EQ(0, remote_compositor_bridge_->num_updates_received()); | |
| 221 EXPECT_EQ(++previous_source_frame, layer_tree_host_->SourceFrameNumber()); | |
| 222 } | |
| 223 | |
| 224 TEST_F(LayerTreeHostRemoteTest, BeginMainFrameCommit) { | |
| 225 // The main frame should run until the commit step. | |
| 226 InSequence s; | |
| 227 int num_of_frames = 1; | |
| 228 EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, | |
| 229 num_of_frames); | |
| 230 | |
| 231 int previous_source_frame = layer_tree_host_->SourceFrameNumber(); | |
| 232 layer_tree_host_->SetNeedsCommit(); | |
| 233 | |
| 234 base::RunLoop().RunUntilIdle(); | |
| 235 EXPECT_TRUE(root_layer_->did_update()); | |
| 236 EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received()); | |
| 237 EXPECT_EQ(++previous_source_frame, layer_tree_host_->SourceFrameNumber()); | |
| 238 } | |
| 239 | |
| 240 TEST_F(LayerTreeHostRemoteTest, BeginMainFrameMultipleRequests) { | |
| 241 // Multiple BeginMainFrame requests should result in a single main frame | |
| 242 // update. | |
| 243 InSequence s; | |
| 244 int num_of_frames = 1; | |
| 245 EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, | |
| 246 num_of_frames); | |
| 247 | |
| 248 layer_tree_host_->SetNeedsAnimate(); | |
| 249 layer_tree_host_->SetNeedsUpdateLayers(); | |
| 250 layer_tree_host_->SetNeedsCommit(); | |
| 251 | |
| 252 base::RunLoop().RunUntilIdle(); | |
| 253 EXPECT_TRUE(root_layer_->did_update()); | |
| 254 EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received()); | |
| 255 } | |
| 256 | |
| 257 TEST_F(LayerTreeHostRemoteTest, CommitRequestThenDeferCommits) { | |
| 258 // Make a commit request, followed by a request to defer commits. | |
| 259 layer_tree_host_->SetNeedsCommit(); | |
| 260 layer_tree_host_->SetDeferCommits(true); | |
| 261 | |
| 262 // We should not have seen any BeginMainFrames. | |
| 263 base::RunLoop().RunUntilIdle(); | |
| 264 Mock::VerifyAndClearExpectations(&mock_layer_tree_host_client_); | |
| 265 EXPECT_FALSE(root_layer_->did_update()); | |
| 266 EXPECT_EQ(0, remote_compositor_bridge_->num_updates_received()); | |
| 267 | |
| 268 // Now enable commits and ensure we see a BeginMainFrame. | |
| 269 layer_tree_host_->SetDeferCommits(false); | |
| 270 InSequence s; | |
| 271 int num_of_frames = 1; | |
| 272 EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, | |
| 273 num_of_frames); | |
| 274 base::RunLoop().RunUntilIdle(); | |
| 275 EXPECT_TRUE(root_layer_->did_update()); | |
| 276 EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received()); | |
| 277 } | |
| 278 | |
| 279 TEST_F(LayerTreeHostRemoteTest, DeferCommitsThenCommitRequest) { | |
| 280 // Defer commits followed by a commit request. | |
| 281 layer_tree_host_->SetDeferCommits(true); | |
| 282 layer_tree_host_->SetNeedsCommit(); | |
| 283 | |
| 284 // We should not have seen any BeginMainFrames. | |
| 285 base::RunLoop().RunUntilIdle(); | |
| 286 Mock::VerifyAndClearExpectations(&mock_layer_tree_host_client_); | |
| 287 EXPECT_FALSE(root_layer_->did_update()); | |
| 288 EXPECT_EQ(0, remote_compositor_bridge_->num_updates_received()); | |
| 289 | |
| 290 // Now enable commits and ensure we see a BeginMainFrame. | |
| 291 layer_tree_host_->SetDeferCommits(false); | |
| 292 InSequence s; | |
| 293 int num_of_frames = 1; | |
| 294 EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, | |
| 295 num_of_frames); | |
| 296 base::RunLoop().RunUntilIdle(); | |
| 297 EXPECT_TRUE(root_layer_->did_update()); | |
| 298 EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received()); | |
| 299 } | |
| 300 | |
| 301 TEST_F(LayerTreeHostRemoteTest, RequestAnimateDuringMainFrame) { | |
| 302 // An animate request during BeginMainFrame should result in a second main | |
| 303 // frame being scheduled. | |
| 304 set_needs_animate_during_main_frame(true); | |
| 305 int num_of_frames = 2; | |
| 306 EXPECT_BEGIN_MAIN_FRAME(mock_layer_tree_host_client_, num_of_frames); | |
| 307 | |
| 308 layer_tree_host_->SetNeedsAnimate(); | |
| 309 | |
| 310 base::RunLoop().RunUntilIdle(); | |
| 311 EXPECT_FALSE(root_layer_->did_update()); | |
| 312 EXPECT_EQ(0, remote_compositor_bridge_->num_updates_received()); | |
| 313 } | |
| 314 | |
| 315 TEST_F(LayerTreeHostRemoteTest, RequestCommitDuringMainFrame) { | |
| 316 // A commit request during a BeginMainFrame scheduled for an animate request | |
| 317 // should go till the commit stage. | |
| 318 set_needs_commit_during_main_frame(true); | |
| 319 int num_of_frames = 1; | |
| 320 EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, | |
| 321 num_of_frames); | |
| 322 | |
| 323 layer_tree_host_->SetNeedsAnimate(); | |
| 324 | |
| 325 base::RunLoop().RunUntilIdle(); | |
| 326 EXPECT_TRUE(root_layer_->did_update()); | |
| 327 EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received()); | |
| 328 } | |
| 329 | |
| 330 TEST_F(LayerTreeHostRemoteTest, RequestCommitDuringLayerUpdates) { | |
| 331 // A layer update during a main frame should result in a commit. | |
| 332 scoped_refptr<Layer> child_layer = make_scoped_refptr(new MockLayer(true)); | |
| 333 root_layer_->AddChild(child_layer); | |
| 334 EXPECT_BEGIN_MAIN_FRAME_AND_COMMIT(mock_layer_tree_host_client_, 1); | |
| 335 | |
| 336 layer_tree_host_->SetNeedsUpdateLayers(); | |
| 337 | |
| 338 base::RunLoop().RunUntilIdle(); | |
| 339 EXPECT_TRUE(root_layer_->did_update()); | |
| 340 EXPECT_EQ(1, remote_compositor_bridge_->num_updates_received()); | |
| 341 } | |
| 342 | |
| 343 } // namespace | |
| 344 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2384333002:
Revert of cc/blimp: Add a LayerTreeHostRemote implementation. (Closed)
