cc: Abstract the LayerTreeHost.

cc/layers/texture_layer_unittest.cc

 // Copyright 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 "cc/layers/texture_layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 622 matching lines @@
 
 class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
  public:
   TextureLayerImplWithMailboxThreadedCallback() = default;
 
   std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     bool synchronous_composite =
         !HasImplThread() &&
-        !layer_tree_host()->settings().single_thread_proxy_scheduler;
+        !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
     // Allow relaim resources for this test so that mailboxes in the display
     // will be returned inside the commit that replaces them.
     bool force_disable_reclaim_resources = false;
     return base::MakeUnique<TestDelegatingOutputSurface>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
-        layer_tree_host()->settings().renderer_settings, ImplThreadTaskRunner(),
-        synchronous_composite, force_disable_reclaim_resources);
+        layer_tree_host()->GetSettings().renderer_settings,
+        ImplThreadTaskRunner(), synchronous_composite,
+        force_disable_reclaim_resources);
   }
 
   // Make sure callback is received on main and doesn't block the impl thread.
   void ReleaseCallback(char mailbox_char,
                        const gpu::SyncToken& sync_token,
                        bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
   }
@@ skipping 135 matching lines @@
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     base::AutoLock lock(activate_count_lock_);
     ++activate_count_;
   }
 
   void DidCommit() override {
     // The first frame doesn't cause anything to be returned so it does not
     // need to wait for activation.
-    if (layer_tree_host()->source_frame_number() > 1) {
+    if (layer_tree_host()->SourceFrameNumber() > 1) {
       base::AutoLock lock(activate_count_lock_);
       // The activate happened before commit is done on the main side.
-      EXPECT_EQ(activate_count_, layer_tree_host()->source_frame_number());
+      EXPECT_EQ(activate_count_, layer_tree_host()->SourceFrameNumber());
     }
 
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // The first mailbox has been activated. Set a new mailbox, and
         // expect the next commit to finish *after* it is activated.
         SetMailbox('2');
         break;
       case 2:
         // The second mailbox has been activated. Remove the layer from
         // the tree to cause another commit/activation. The commit should
         // finish *after* the layer is removed from the active tree.
         layer_->RemoveFromParent();
@@ skipping 223 matching lines @@
 // Checks that TextureLayer::Update does not cause an extra commit when setting
 // the texture mailbox.
 class TextureLayerNoExtraCommitForMailboxTest
     : public LayerTreeTest,
       public TextureLayerClient {
  public:
   // TextureLayerClient implementation.
   bool PrepareTextureMailbox(
       TextureMailbox* texture_mailbox,
       std::unique_ptr<SingleReleaseCallback>* release_callback) override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       // Once this has been committed, the mailbox will be released.
       *texture_mailbox = TextureMailbox();
       return true;
     }
 
     *texture_mailbox = TextureMailbox(MailboxFromChar('1'),
                                       SyncTokenFromUInt(0x123), GL_TEXTURE_2D);
     *release_callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerNoExtraCommitForMailboxTest::MailboxReleased,
                    base::Unretained(this)));
@@ skipping 15 matching lines @@
     texture_layer_->SetIsDrawable(true);
     root->AddChild(texture_layer_);
 
     layer_tree()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         EXPECT_FALSE(proxy()->MainFrameWillHappenForTesting());
         // Invalidate the texture layer to clear the mailbox before
         // ending the test.
         texture_layer_->SetNeedsDisplay();
         break;
       case 2:
         break;
       default:
         NOTREACHED();
@@ skipping 251 matching lines @@
     callback_count_ = 0;
 
     // Set the mailbox on the main thread.
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // Delete the TextureLayer on the main thread while the mailbox is in
         // the impl tree.
         layer_->RemoveFromParent();
         layer_ = nullptr;
         break;
     }
   }
 
   void AfterTest() override { EXPECT_EQ(1, callback_count_); }
@@ skipping 49 matching lines @@
     callback_count_ = 0;
 
     // Set the mailbox on the main thread.
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // Remove the TextureLayer on the main thread while the mailbox is in
         // the impl tree, but don't delete the TextureLayer until after the impl
         // tree side is deleted.
         layer_->RemoveFromParent();
         break;
       case 2:
         layer_ = nullptr;
         break;
     }
   }
 
   void AfterTest() override { EXPECT_EQ(1, callback_count_); }
 
  private:
   base::ThreadChecker main_thread_;
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc