cc: Remove ScopedPtrVector and cc::remove_if.

cc/layers/delegated_renderer_layer_impl.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/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 133 matching lines @@
   // Save the new frame's resources, but don't give them to the ResourceProvider
   // until they are active, since the resources on the active tree will still be
   // used and we don't want to return them early.
   resources_.swap(resources_in_frame);
   TakeOwnershipOfResourcesIfOnActiveTree(resources_);
 
   inverse_device_scale_factor_ = 1.0f / frame_data->device_scale_factor;
   // Display size is already set so we can compute what the damage rect
   // will be in layer space. The damage may exceed the visible portion of
   // the frame, so intersect the damage to the layer's bounds.
-  RenderPass* new_root_pass = render_pass_list.back();
+  RenderPass* new_root_pass = render_pass_list.back().get();
   gfx::Size frame_size = new_root_pass->output_rect.size();
   gfx::Rect damage_in_layer =
       gfx::ScaleToEnclosingRect(damage_in_frame, inverse_device_scale_factor_);
   SetUpdateRect(gfx::IntersectRects(
       gfx::UnionRects(update_rect(), damage_in_layer), gfx::Rect(bounds())));
 
   SetRenderPasses(&render_pass_list);
   have_render_passes_to_push_ = true;
 }
 
 void DelegatedRendererLayerImpl::TakeOwnershipOfResourcesIfOnActiveTree(
     const ResourceProvider::ResourceIdSet& resources) {
   DCHECK(child_id_);
   if (!layer_tree_impl()->IsActiveTree())
     return;
   layer_tree_impl()->resource_provider()->DeclareUsedResourcesFromChild(
       child_id_, resources);
 }
 
 void DelegatedRendererLayerImpl::SetRenderPasses(
     RenderPassList* render_passes_in_draw_order) {
   ClearRenderPasses();
 
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     RenderPassList::iterator to_take =
         render_passes_in_draw_order->begin() + i;
     render_passes_index_by_id_.insert(
         RenderPassToIndexMap::value_type((*to_take)->id, i));
-    scoped_ptr<RenderPass> taken_render_pass =
-        render_passes_in_draw_order->take(to_take);
-    render_passes_in_draw_order_.push_back(taken_render_pass.Pass());
+    render_passes_in_draw_order_.push_back(to_take->Pass());
   }
 
   // Give back an empty array instead of nulls.
   render_passes_in_draw_order->clear();
 
   // The render passes given here become part of the RenderSurfaceLayerList, so
   // changing them requires recomputing the RenderSurfaceLayerList.
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
@@ skipping 43 matching lines @@
   *output_render_pass_id =
       RenderPassId(id(), IndexToId(delegated_render_pass_index));
   return true;
 }
 
 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
     RenderPassSink* render_pass_sink) {
   DCHECK(HasContributingDelegatedRenderPasses());
 
   const RenderPass* root_delegated_render_pass =
-      render_passes_in_draw_order_.back();
+      render_passes_in_draw_order_.back().get();
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
   gfx::Transform delegated_frame_to_root_transform = screen_space_transform();
   delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_,
                                           inverse_device_scale_factor_);
 
   for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
     RenderPassId output_render_pass_id;
     bool present =
         ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id,
                                      &output_render_pass_id);
@@ skipping 23 matching lines @@
     AppendQuadsData* append_quads_data) {
   AppendRainbowDebugBorder(render_pass);
 
   // This list will be empty after a lost context until a new frame arrives.
   if (render_passes_in_draw_order_.empty())
     return;
 
   RenderPassId target_render_pass_id = render_pass->id;
 
   const RenderPass* root_delegated_render_pass =
-      render_passes_in_draw_order_.back();
+      render_passes_in_draw_order_.back().get();
 
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
 
   // If the index of the RenderPassId is 0, then it is a RenderPass generated
   // for a layer in this compositor, not the delegating renderer. Then we want
   // to merge our root RenderPass with the target RenderPass. Otherwise, it is
   // some RenderPass which we added from the delegating renderer.
   bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
   if (should_merge_root_render_pass_with_target) {
     // Verify that the RenderPass we are appending to is created by our
     // render_target.
     DCHECK(target_render_pass_id.layer_id == render_target()->id());
 
     AppendRenderPassQuads(render_pass,
                           root_delegated_render_pass,
                           frame_size);
   } else {
     // Verify that the RenderPass we are appending to was created by us.
     DCHECK(target_render_pass_id.layer_id == id());
 
     size_t render_pass_index = IdToIndex(target_render_pass_id.index);
     const RenderPass* delegated_render_pass =
-        render_passes_in_draw_order_[render_pass_index];
+        render_passes_in_draw_order_[render_pass_index].get();
     AppendRenderPassQuads(render_pass,
                           delegated_render_pass,
                           frame_size);
   }
 }
 
 void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
     RenderPass* render_pass) {
   if (!ShowDebugBorders())
     return;
@@ skipping 85 matching lines @@
     RenderPass* render_pass,
     const RenderPass* delegated_render_pass,
     const gfx::Size& frame_size) const {
   const SharedQuadState* delegated_shared_quad_state = nullptr;
   SharedQuadState* output_shared_quad_state = nullptr;
 
   gfx::Transform delegated_frame_to_target_transform = draw_transform();
   delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
                                             inverse_device_scale_factor_);
   bool is_root_delegated_render_pass =
-      delegated_render_pass == render_passes_in_draw_order_.back();
+      delegated_render_pass == render_passes_in_draw_order_.back().get();
   for (const auto& delegated_quad : delegated_render_pass->quad_list) {
     if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
       delegated_shared_quad_state = delegated_quad->shared_quad_state;
       output_shared_quad_state = render_pass->CreateAndAppendSharedQuadState();
       output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
 
       if (is_root_delegated_render_pass) {
         output_shared_quad_state->quad_to_target_transform.ConcatTransform(
             delegated_frame_to_target_transform);
 
@@ skipping 80 matching lines @@
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc