cc: Chromify the LayerTreeHostImpl class.

cc/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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/layer_tree_host.h"
 
 #include "cc/delegated_frame_data.h"
 #include "cc/delegated_renderer_layer.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/layer_tree_impl.h"
@@ skipping 92 matching lines @@
         did_reset_child_id_(false) {}
 
   virtual void didCommit() OVERRIDE {
     if (testEnded())
       return;
     delegated_->SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1),
                                              gfx::Rect(0, 0, 1, 1)));
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     ++num_activates_;
     switch(num_activates_) {
       case 2:
         EXPECT_TRUE(delegated_impl->ChildId());
         EXPECT_FALSE(did_reset_child_id_);
 
-        host_impl->resourceProvider()->GraphicsContext3D()->loseContextCHROMIUM(
+        host_impl->resource_provider()->GraphicsContext3D()->loseContextCHROMIUM(
             GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
         break;
       case 3:
         EXPECT_TRUE(delegated_impl->ChildId());
         EXPECT_TRUE(did_reset_child_id_);
         endTest();
         break;
     }
   }
 
   virtual void initializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                            bool success) OVERRIDE {
     EXPECT_TRUE(success);
 
     if (num_activates_ < 2)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     EXPECT_EQ(2, num_activates_);
     EXPECT_FALSE(delegated_impl->ChildId());
     did_reset_child_id_ = true;
   }
 
   virtual void afterTest() OVERRIDE {}
 
@@ skipping 83 matching lines @@
         break;
       case 14:
         // Should create zero damage.
         m_layerTreeHost->SetNeedsCommit();
         break;
     }
     first_draw_for_source_frame_ = true;
   }
 
   virtual bool prepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData& frame,
+                                     LayerTreeHostImpl::FrameData* frame,
                                      bool result) {
     EXPECT_TRUE(result);
 
     if (!first_draw_for_source_frame_)
       return result;
 
-    gfx::RectF damage_rect = frame.renderPasses.back()->damage_rect;
+    gfx::RectF damage_rect = frame->render_passes.back()->damage_rect;
 
-    switch (host_impl->activeTree()->source_frame_number()) {
+    switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // Before the layer has a frame to display it should not
         // be visible at all, and not damage anything.
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
                   damage_rect.ToString());
         break;
       case 1:
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
                   damage_rect.ToString());
         break;
@@ skipping 79 matching lines @@
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame2.get(), 999);
     AddTextureQuad(frame2.get(), 555);
     AddTransferableResource(frame2.get(), 555);
     delegated_->SetFrameData(frame2.Pass());
 
     postSetNeedsCommitToMainThread();
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // Both frames' resources should be in the parent's resource provider.
     EXPECT_EQ(2u, map.size());
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
 
     EXPECT_EQ(2u, delegated_impl->Resources().size());
     EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
     EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
@@ skipping 16 matching lines @@
     AddTextureQuad(frame.get(), 999);
     AddTransferableResource(frame.get(), 999);
     AddTextureQuad(frame.get(), 555);
     AddTransferableResource(frame.get(), 555);
     delegated_->SetFrameData(frame.Pass());
 
     postSetNeedsCommitToMainThread();
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The frame's resource should be in the parent's resource provider.
     EXPECT_EQ(2u, map.size());
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
 
     ResourceProvider::ResourceId parent_resource_id1 = map.find(999)->second;
     EXPECT_NE(parent_resource_id1, 999);
     ResourceProvider::ResourceId parent_resource_id2 = map.find(555)->second;
@@ skipping 200 matching lines @@
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() != 3)
+    if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The bad frame should be dropped. So we should only have one quad (the
     // one with resource 999) on the impl tree. And only 999 will be present
     // in the parent's resource provider.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(999));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
     EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
@@ skipping 68 matching lines @@
         break;
       case 4:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         endTest();
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() != 3)
+    if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The third frame has all of the resources in it again, the delegated
     // renderer layer should continue to own the resources for it.
     EXPECT_EQ(3u, map.size());
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
     EXPECT_EQ(1u, map.count(444));
 
     EXPECT_EQ(3u, delegated_impl->Resources().size());
@@ skipping 77 matching lines @@
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(1u, resources.size());
         EXPECT_EQ(555, resources[0].id);
 
         endTest();
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() < 1)
+    if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
-    switch (host_impl->activeTree()->source_frame_number()) {
+    switch (host_impl->active_tree()->source_frame_number()) {
       case 1: {
         // We have the first good frame with just 990 and 555 in it.
         // layer.
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
@@ skipping 79 matching lines @@
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(1u, resources.size());
         EXPECT_EQ(999, resources[0].id);
 
         endTest();
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() != 1)
+    if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The layer only held on to the resource that was used.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(555));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
     EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
   }
 
@@ skipping 34 matching lines @@
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(1u, resources.size());
         EXPECT_EQ(999, resources[0].id);
 
         endTest();
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() != 1)
+    if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The layer only held on to the resource that was used.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(555));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
     EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
   }
 
@@ skipping 48 matching lines @@
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(1u, resources.size());
         EXPECT_EQ(999, resources[0].id);
 
         endTest();
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() < 1)
+    if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
-    switch (host_impl->activeTree()->source_frame_number()) {
+    switch (host_impl->active_tree()->source_frame_number()) {
       case 1: {
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
 
         // The 999 resource is sent to a grandparent compositor.
         ResourceProvider::ResourceIdArray resources_for_parent;
         resources_for_parent.push_back(map.find(999)->second);
         TransferableResourceArray transferable_resources;
-        host_impl->resourceProvider()->PrepareSendToParent(
+        host_impl->resource_provider()->PrepareSendToParent(
             resources_for_parent, &transferable_resources);
         break;
       }
       case 2: {
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         /// 999 is in the parent, so not held by delegated renderer layer.
         EXPECT_EQ(1u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
 
         // Receive 999 back from the grandparent.
         TransferableResource resource;
         resource.id = map.find(999)->second;
         TransferableResourceArray transferable_resources;
         transferable_resources.push_back(resource);
-        host_impl->resourceProvider()->ReceiveFromParent(
+        host_impl->resource_provider()->ReceiveFromParent(
             transferable_resources);
         break;
       }
       case 3:
         // 999 should be released.
         EXPECT_EQ(1u, map.size());
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(1u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
@@ skipping 51 matching lines @@
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(1u, resources.size());
         EXPECT_EQ(444, resources[0].id);
 
         endTest();
         break;
     }
   }
 
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() < 1)
+    if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
-    LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
-        host_impl->resourceProvider()->GetChildToParentMap(
+        host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
-    switch (host_impl->activeTree()->source_frame_number()) {
+    switch (host_impl->active_tree()->source_frame_number()) {
       case 1:
         EXPECT_EQ(3u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
         EXPECT_EQ(1u, map.count(444));
 
         EXPECT_EQ(3u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(444)->second));
@@ skipping 16 matching lines @@
     }
   }
 
   virtual void afterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCommitWithoutTake)
 
 }  // namespace
 }  // namespace cc