cc: Remove ScopedPtrVector and cc::remove_if.

cc/output/overlay_unittest.cc

 // Copyright 2014 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/base/region.h"
-#include "cc/base/scoped_ptr_vector.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
 #include "cc/output/overlay_strategy_sandwich.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
 #include "cc/quads/render_pass.h"
@@ skipping 286 matching lines @@
                                 const SharedQuadState* shared_quad_state,
                                 RenderPass* render_pass) {
   CreateOpaqueQuadAt(resource_provider, shared_quad_state, render_pass,
                      kOverlayRect);
 }
 
 static void CompareRenderPassLists(const RenderPassList& expected_list,
                                    const RenderPassList& actual_list) {
   EXPECT_EQ(expected_list.size(), actual_list.size());
   for (size_t i = 0; i < actual_list.size(); ++i) {
-    RenderPass* expected = expected_list[i];
-    RenderPass* actual = actual_list[i];
+    RenderPass* expected = expected_list[i].get();
+    RenderPass* actual = actual_list[i].get();
 
     EXPECT_EQ(expected->id, actual->id);
     EXPECT_EQ(expected->output_rect, actual->output_rect);
     EXPECT_EQ(expected->transform_to_root_target,
               actual->transform_to_root_target);
     EXPECT_EQ(expected->damage_rect, actual->damage_rect);
     EXPECT_EQ(expected->has_transparent_background,
               actual->has_transparent_background);
 
     EXPECT_EQ(expected->shared_quad_state_list.size(),
@@ skipping 87 matching lines @@
   pass_list.push_back(pass.Pass());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
                                          &candidate_list, &damage_rect_);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
 
-  RenderPass* main_pass = pass_list.back();
+  RenderPass* main_pass = pass_list.back().get();
   // Check that the quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd(); ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
   // Check that the right resource id got extracted.
   EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
@@ skipping 118 matching lines @@
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
                                          &candidate_list, &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(2U, candidate_list.size());
 
-  RenderPass* main_pass = pass_list.back();
+  RenderPass* main_pass = pass_list.back().get();
   // Check that the quad is gone.
   EXPECT_EQ(3U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd(); ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
   EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
   EXPECT_EQ(gfx::RectF(32.f, 32.f, 32.f, 32.f), candidate_list[0].display_rect);
@@ skipping 26 matching lines @@
 
   // Then some opaque background.
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      gfx::Rect(kDisplaySize));
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // Run the overlay strategy on that input.
-  RenderPass* main_pass = pass_list.back();
+  RenderPass* main_pass = pass_list.back().get();
   OverlayCandidateList candidate_list;
   EXPECT_EQ(4U, main_pass->quad_list.size());
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
                                          &candidate_list, &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(3U, candidate_list.size());
 
   // Check that the candidate quad is gone and that we now have two transparent
   // quads for the same region that was covered on the overlay.
   EXPECT_EQ(5U, main_pass->quad_list.size());
@@ skipping 73 matching lines @@
   pass_list.push_back(pass.Pass());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
                                          &candidate_list, &damage_rect_);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
 
-  RenderPass* main_pass = pass_list.back();
+  RenderPass* main_pass = pass_list.back().get();
   // Check that the quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
        ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
   }
 
   // Check that the right resource id got extracted.
@@ skipping 626 matching lines @@
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(45.f);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   CALayerOverlayList ca_layer_list;
-  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  OverlayCandidateList overlay_list(
+      BackbufferOverlayList(pass_list.back().get()));
   overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
                                          &ca_layer_list, &overlay_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, ca_layer_list.size());
 }
 
 TEST_F(CALayerOverlayTest, Disallow3DTransform) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutXAxis(45.f);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   CALayerOverlayList ca_layer_list;
-  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  OverlayCandidateList overlay_list(
+      BackbufferOverlayList(pass_list.back().get()));
   overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
                                          &ca_layer_list, &overlay_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, pass_list.back()->quad_list.size());
   EXPECT_EQ(1U, overlay_list.size());
   EXPECT_EQ(0U, ca_layer_list.size());
 }
 
 TEST_F(CALayerOverlayTest, AllowContainingClip) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = kOverlayRect;
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   CALayerOverlayList ca_layer_list;
-  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  OverlayCandidateList overlay_list(
+      BackbufferOverlayList(pass_list.back().get()));
   overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
                                          &ca_layer_list, &overlay_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, ca_layer_list.size());
 }
 
 TEST_F(CALayerOverlayTest, SkipDisjointClip) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect =
       gfx::Rect(128, 128, 128, 128);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   CALayerOverlayList ca_layer_list;
-  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  OverlayCandidateList overlay_list(
+      BackbufferOverlayList(pass_list.back().get()));
   overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
                                          &ca_layer_list, &overlay_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(0U, ca_layer_list.size());
 }
 
 TEST_F(CALayerOverlayTest, DisallowNontrivialClip) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   CALayerOverlayList ca_layer_list;
-  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  OverlayCandidateList overlay_list(
+      BackbufferOverlayList(pass_list.back().get()));
   overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
                                          &ca_layer_list, &overlay_list);
 
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, pass_list.back()->quad_list.size());
   EXPECT_EQ(1U, overlay_list.size());
   EXPECT_EQ(0U, ca_layer_list.size());
 }
 
 TEST_F(CALayerOverlayTest, SkipTransparent) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->opacity = 0;
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   CALayerOverlayList ca_layer_list;
-  OverlayCandidateList overlay_list(BackbufferOverlayList(pass_list.back()));
+  OverlayCandidateList overlay_list(
+      BackbufferOverlayList(pass_list.back().get()));
   overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
                                          &ca_layer_list, &overlay_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(0U, ca_layer_list.size());
 }
 
 class OverlayInfoRendererGL : public GLRenderer {
  public:
@@ skipping 341 matching lines @@
   renderer_->BeginDrawingFrame(&frame_no_overlays);
   renderer_->FinishDrawingFrame(&frame_no_overlays);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc