cc: Remove ScopedPtrVector and cc::remove_if.

cc/trees/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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 131 matching lines @@
     resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
     GLbyte arbitrary_mailbox[GL_MAILBOX_SIZE_CHROMIUM] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
         3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4,
         5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4};
     resource.mailbox_holder.mailbox.SetName(arbitrary_mailbox);
     frame->resource_list.push_back(resource);
   }
 
   void AddTextureQuad(DelegatedFrameData* frame, ResourceId resource_id) {
-    RenderPass* render_pass = frame->render_pass_list[0];
+    RenderPass* render_pass = frame->render_pass_list[0].get();
     SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     float vertex_opacity[4] = { 1.f, 1.f, 1.f, 1.f };
     quad->SetNew(sqs,
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Rect(0, 0, 10, 10),
                  resource_id,
                  false,
@@ skipping 83 matching lines @@
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostDelegatedTest::SetupTree();
   }
 
   void BeginTest() override {
     resource_collection_->SetClient(this);
     PostSetNeedsCommitToMainThread();
   }
 
   void SetFrameData(scoped_ptr<DelegatedFrameData> frame_data) {
-    RenderPass* root_pass = frame_data->render_pass_list.back();
+    RenderPass* root_pass = frame_data->render_pass_list.back().get();
     gfx::Size frame_size = root_pass->output_rect.size();
 
     if (frame_provider_.get() && frame_size == frame_provider_->frame_size()) {
       frame_provider_->SetFrameData(frame_data.Pass());
       return;
     }
 
     if (delegated_.get()) {
       delegated_->RemoveFromParent();
       delegated_ = NULL;
@@ skipping 49 matching lines @@
       return;
     SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     TestContextProvider* context_provider = static_cast<TestContextProvider*>(
         host_impl->output_surface()->context_provider());
 
     ++num_activates_;
     switch (num_activates_) {
       case 2:
         EXPECT_TRUE(delegated_impl->ChildId());
         EXPECT_FALSE(did_reset_child_id_);
 
@@ skipping 12 matching lines @@
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     EXPECT_TRUE(success);
 
     if (num_activates_ < 2)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     EXPECT_EQ(2, num_activates_);
     EXPECT_FALSE(delegated_impl->ChildId());
     did_reset_child_id_ = true;
   }
 
  protected:
   int num_activates_;
   bool did_reset_child_id_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCreateChildId);
 
 class LayerTreeHostDelegatedTestDontUseLostChildIdAfterCommit
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  protected:
   void BeginTest() override {
     SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
     LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::BeginTest();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // Act like the context was lost while the layer is in the pending tree.
     LayerImpl* root_impl = host_impl->sync_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
     delegated_impl->ReleaseResources();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     // Should not try to activate a frame without a child id. If we did try to
     // activate we would crash.
     EXPECT_FALSE(delegated_impl->ChildId());
     EndTest();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestDontUseLostChildIdAfterCommit);
@@ skipping 52 matching lines @@
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     EXPECT_TRUE(success);
 
     if (num_activates_ < 2)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     EXPECT_EQ(2, num_activates_);
     // Resources should have gotten cleared after the context was lost.
     EXPECT_EQ(0U, delegated_impl->Resources().size());
   }
 
   void AfterTest() override {
     LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::AfterTest();
     EXPECT_EQ(2, num_output_surfaces_initialized_);
   }
@@ skipping 236 matching lines @@
       EXPECT_RESOURCES(expected, returned_resources);
       EXPECT_TRUE(TestAndResetAvailable());
     }
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         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));
 
@@ skipping 19 matching lines @@
     AddTextureQuad(frame.get(), 555);
     AddTransferableResource(frame.get(), 555);
     SetFrameData(frame.Pass());
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         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));
 
@@ skipping 224 matching lines @@
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         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(999));
 
-    const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
+    const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0].get();
     EXPECT_EQ(1u, pass->quad_list.size());
     const TextureDrawQuad* quad =
         TextureDrawQuad::MaterialCast(pass->quad_list.front());
     EXPECT_EQ(map.find(999)->second, quad->resource_id());
 
     EndTest();
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     ReturnUnusedResourcesFromParent(host_impl);
@@ skipping 73 matching lines @@
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         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());
     EXPECT_EQ(1u, delegated_impl->Resources().count(999));
     EXPECT_EQ(1u, delegated_impl->Resources().count(555));
     EXPECT_EQ(1u, delegated_impl->Resources().count(444));
 
-    const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
+    const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0].get();
     EXPECT_EQ(3u, pass->quad_list.size());
     const TextureDrawQuad* quad1 =
         TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
     EXPECT_EQ(map.find(999)->second, quad1->resource_id());
     const TextureDrawQuad* quad2 =
         TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
     EXPECT_EQ(map.find(555)->second, quad2->resource_id());
     const TextureDrawQuad* quad3 =
         TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(2));
     EXPECT_EQ(map.find(444)->second, quad3->resource_id());
@@ skipping 80 matching lines @@
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     ReturnUnusedResourcesFromParent(host_impl);
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 1: {
         // We have the first good frame with just 999 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(999));
         EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
-        const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
+        const RenderPass* pass =
+            delegated_impl->RenderPassesInDrawOrder()[0].get();
         EXPECT_EQ(2u, pass->quad_list.size());
         const TextureDrawQuad* quad1 =
             TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
         EXPECT_EQ(map.find(999)->second, quad1->resource_id());
         const TextureDrawQuad* quad2 =
             TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
         EXPECT_EQ(map.find(555)->second, quad2->resource_id());
         break;
       }
       case 2: {
         // We only keep resources from the last valid frame.
         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(999));
         EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
         // The bad frame is dropped though, we still have the frame with 999 and
         // 555 in it.
-        const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
+        const RenderPass* pass =
+            delegated_impl->RenderPassesInDrawOrder()[0].get();
         EXPECT_EQ(2u, pass->quad_list.size());
         const TextureDrawQuad* quad1 =
             TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
         EXPECT_EQ(map.find(999)->second, quad1->resource_id());
         const TextureDrawQuad* quad2 =
             TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
         EXPECT_EQ(map.find(555)->second, quad2->resource_id());
         break;
       }
       case 3: {
         // We have the new good frame with just 999 in it.
         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(999));
 
-        const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
+        const RenderPass* pass =
+            delegated_impl->RenderPassesInDrawOrder()[0].get();
         EXPECT_EQ(1u, pass->quad_list.size());
         const TextureDrawQuad* quad1 =
             TextureDrawQuad::MaterialCast(pass->quad_list.front());
         EXPECT_EQ(map.find(999)->second, quad1->resource_id());
         break;
       }
     }
   }
 };
 
@@ skipping 39 matching lines @@
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         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());
@@ skipping 55 matching lines @@
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         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());
@@ skipping 46 matching lines @@
         // The impl side will get back the resource at some point.
         ImplThreadTaskRunner()->PostTask(FROM_HERE,
                                          receive_resource_on_thread_);
         break;
     }
   }
 
   void ReceiveResourceOnThread(LayerTreeHostImpl* host_impl) {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // Receive 999 back from the grandparent.
     CompositorFrameAck ack;
     output_surface()->ReturnResource(map.find(999)->second, &ack);
     host_impl->ReclaimResources(&ack);
   }
@@ skipping 12 matching lines @@
 
     EndTest();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     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));
@@ skipping 112 matching lines @@
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     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));
@@ skipping 524 matching lines @@
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
-        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+        static_cast<FakeDelegatedRendererLayerImpl*>(
+            root_impl->children()[0].get());
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 1:
         if (!host_impl->pending_tree()) {
           // Frame 2 is blocked from activating until another draw happens with
           // Frame 1. This ensures we draw a different active frame from
           // what's in the pending tree.
@@ skipping 26 matching lines @@
   }
 
   bool drew_with_pending_tree_;
 };
 
 // This test blocks activation which is not supported for single thread mode.
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(LayerTreeHostDelegatedTestActiveFrameIsValid);
 
 }  // namespace
 }  // namespace cc