cc: Remove ScopedPtrVector and cc::remove_if.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 742 matching lines @@
     quad->SetNew(shared_quad_state,
                  screen_space_rect,
                  visible_screen_space_rect,
                  screen_background_color,
                  false);
   }
 }
 
 static RenderPass* FindRenderPassById(const RenderPassList& list,
                                       RenderPassId id) {
-  auto it = std::find_if(list.begin(), list.end(),
-                         [id](const RenderPass* p) { return p->id == id; });
-  return it == list.end() ? nullptr : *it;
+  auto it = std::find_if(
+      list.begin(), list.end(),
+      [id](const scoped_ptr<RenderPass>& p) { return p->id == id; });
+  return it == list.end() ? nullptr : it->get();
 }
 
 DrawResult LayerTreeHostImpl::CalculateRenderPasses(
     FrameData* frame) {
   DCHECK(frame->render_passes.empty());
   DCHECK(CanDraw());
   DCHECK(active_tree_->root_layer());
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
@@ skipping 44 matching lines @@
       render_surface->AppendRenderPasses(frame);
   }
 
   // When we are displaying the HUD, change the root damage rect to cover the
   // entire root surface. This will disable partial-swap/scissor optimizations
   // that would prevent the HUD from updating, since the HUD does not cause
   // damage itself, to prevent it from messing with damage visualizations. Since
   // damage visualizations are done off the LayerImpls and RenderSurfaceImpls,
   // changing the RenderPass does not affect them.
   if (active_tree_->hud_layer()) {
-    RenderPass* root_pass = frame->render_passes.back();
+    RenderPass* root_pass = frame->render_passes.back().get();
     root_pass->damage_rect = root_pass->output_rect;
   }
 
   // Because the active tree could be drawn again if this fails for some reason,
   // clear all of the copy request flags so that sanity checks for the counts
   // succeed.
   if (!active_tree_->LayersWithCopyOutputRequest().empty()) {
     LayerTreeHostCommon::CallFunctionForSubtree(
         active_tree_->root_layer(), [](LayerImpl* layer) {
           layer->set_num_layer_or_descendant_with_copy_request(0);
@@ skipping 146 matching lines @@
     for (const auto& quad : render_pass->quad_list)
       DCHECK(quad->shared_quad_state);
   }
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 #endif
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(
         active_tree_->RootScrollLayerDeviceViewportBounds(),
-        frame->render_passes.back(), active_tree_->root_layer(),
+        frame->render_passes.back().get(), active_tree_->root_layer(),
         active_tree_->background_color(), unoccluded_screen_space_region);
   }
 
   RemoveRenderPasses(frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
 
   // Any copy requests left in the tree are not going to get serviced, and
   // should be aborted.
-  ScopedPtrVector<CopyOutputRequest> requests_to_abort;
+  std::vector<scoped_ptr<CopyOutputRequest>> requests_to_abort;
   while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
     LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
     layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
   }
   for (size_t i = 0; i < requests_to_abort.size(); ++i)
     requests_to_abort[i]->SendEmptyResult();
 
   // If we're making a frame to draw, it better have at least one render pass.
   DCHECK(!frame->render_passes.empty());
 
@@ skipping 115 matching lines @@
 
   // A set of RenderPasses that we have seen.
   std::set<RenderPassId> pass_exists;
   // A set of RenderPassDrawQuads that we have seen (stored by the RenderPasses
   // they refer to).
   base::SmallMap<base::hash_map<RenderPassId, int>> pass_references;
 
   // Iterate RenderPasses in draw order, removing empty render passes (except
   // the root RenderPass).
   for (size_t i = 0; i < frame->render_passes.size(); ++i) {
-    RenderPass* pass = frame->render_passes[i];
+    RenderPass* pass = frame->render_passes[i].get();
 
     // Remove orphan RenderPassDrawQuads.
     for (auto it = pass->quad_list.begin(); it != pass->quad_list.end();) {
       if (it->material != DrawQuad::RENDER_PASS) {
         ++it;
         continue;
       }
       const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(*it);
       // If the RenderPass doesn't exist, we can remove the quad.
       if (pass_exists.count(quad->render_pass_id)) {
@@ skipping 22 matching lines @@
     pass_exists.insert(pass->id);
   }
 
   // Remove RenderPasses that are not referenced by any draw quads or copy
   // requests (except the root RenderPass).
   for (size_t i = 0; i < frame->render_passes.size() - 1; ++i) {
     // Iterating from the back of the list to the front, skipping over the
     // back-most (root) pass, in order to remove each qualified RenderPass, and
     // drop references to earlier RenderPasses allowing them to be removed to.
     RenderPass* pass =
-        frame->render_passes[frame->render_passes.size() - 2 - i];
+        frame->render_passes[frame->render_passes.size() - 2 - i].get();
     if (!pass->copy_requests.empty())
       continue;
     if (pass_references[pass->id])
       continue;
 
     for (auto it = pass->quad_list.begin(); it != pass->quad_list.end(); ++it) {
       if (it->material != DrawQuad::RENDER_PASS)
         continue;
       const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(*it);
       pass_references[quad->render_pass_id]--;
@@ skipping 1808 matching lines @@
   gfx::ScrollOffset scroll_delta = layer_impl->PullDeltaForMainThread();
 
   if (!scroll_delta.IsZero()) {
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layer_id = layer_impl->id();
     scroll.scroll_delta = gfx::Vector2d(scroll_delta.x(), scroll_delta.y());
     scroll_info->scrolls.push_back(scroll);
   }
 
   for (size_t i = 0; i < layer_impl->children().size(); ++i)
-    CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
+    CollectScrollDeltas(scroll_info, layer_impl->children()[i].get());
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta =
       active_tree_->page_scale_factor()->PullDeltaForMainThread();
   scroll_info->top_controls_delta =
       active_tree()->top_controls_shown_ratio()->PullDeltaForMainThread();
@@ skipping 666 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc