cc: Remove ScopedPtrVector and cc::remove_if.

cc/output/direct_renderer.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/output/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 133 matching lines @@
     const gfx::Vector2d& amount) {
   enlarge_pass_texture_amount_ = amount;
 }
 
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
   base::hash_map<RenderPassId, gfx::Size> render_passes_in_frame;
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
     render_passes_in_frame.insert(std::pair<RenderPassId, gfx::Size>(
         render_passes_in_draw_order[i]->id,
-        RenderPassTextureSize(render_passes_in_draw_order[i])));
+        RenderPassTextureSize(render_passes_in_draw_order[i].get())));
 
   std::vector<RenderPassId> passes_to_delete;
   for (auto pass_iter = render_pass_textures_.begin();
        pass_iter != render_pass_textures_.end(); ++pass_iter) {
     base::hash_map<RenderPassId, gfx::Size>::const_iterator it =
         render_passes_in_frame.find(pass_iter->first);
     if (it == render_passes_in_frame.end()) {
       passes_to_delete.push_back(pass_iter->first);
       continue;
     }
@@ skipping 26 matching lines @@
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                float device_scale_factor,
                                const gfx::Rect& device_viewport_rect,
                                const gfx::Rect& device_clip_rect,
                                bool disable_picture_quad_image_filtering) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS(
       "Renderer4.renderPassCount",
       base::saturated_cast<int>(render_passes_in_draw_order->size()));
 
-  const RenderPass* root_render_pass = render_passes_in_draw_order->back();
+  const RenderPass* root_render_pass =
+      render_passes_in_draw_order->back().get();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.render_passes_in_draw_order = render_passes_in_draw_order;
   frame.root_render_pass = root_render_pass;
   frame.root_damage_rect = Capabilities().using_partial_swap
                                ? root_render_pass->damage_rect
                                : root_render_pass->output_rect;
   frame.root_damage_rect.Union(next_root_damage_rect_);
   next_root_damage_rect_ = gfx::Rect();
@@ skipping 37 matching lines @@
     } else {
       overlay_processor_->ProcessForOverlays(
           resource_provider_, render_passes_in_draw_order, &frame.overlay_list,
           &frame.root_damage_rect);
 
       // No need to render in case the damage rect is completely composited
       // using
       // overlays and dont have any copy requests.
       if (frame.root_damage_rect.IsEmpty()) {
         bool handle_copy_requests = false;
-        for (auto* pass : *render_passes_in_draw_order) {
+        for (const auto& pass : *render_passes_in_draw_order) {
           if (!pass->copy_requests.empty()) {
             handle_copy_requests = true;
             break;
           }
         }
 
         if (!handle_copy_requests) {
           BindFramebufferToOutputSurface(&frame);
           FinishDrawingFrame(&frame);
           render_passes_in_draw_order->clear();
           return;
         }
         overlay_processor_->ProcessForOverlays(
             resource_provider_, render_passes_in_draw_order,
             &frame.overlay_list, &frame.root_damage_rect);
       }
     }
   }
 
-  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
-    RenderPass* pass = render_passes_in_draw_order->at(i);
-    DrawRenderPass(&frame, pass);
+  for (const auto& pass : *render_passes_in_draw_order) {
+    DrawRenderPass(&frame, pass.get());
 
-    for (ScopedPtrVector<CopyOutputRequest>::iterator it =
-             pass->copy_requests.begin();
-         it != pass->copy_requests.end();
-         ++it) {
-      if (it != pass->copy_requests.begin()) {
-        // Doing a readback is destructive of our state on Mac, so make sure
-        // we restore the state between readbacks. http://crbug.com/99393.
-        UseRenderPass(&frame, pass);
-      }
-      CopyCurrentRenderPassToBitmap(&frame, pass->copy_requests.take(it));
+    bool first_request = true;
+    for (auto& copy_request : pass->copy_requests) {
+      // Doing a readback is destructive of our state on Mac, so make sure
+      // we restore the state between readbacks. http://crbug.com/99393.
+      if (!first_request)
+        UseRenderPass(&frame, pass.get());
+      CopyCurrentRenderPassToBitmap(&frame, std::move(copy_request));
+      first_request = false;
     }
   }
   FinishDrawingFrame(&frame);
 
   render_passes_in_draw_order->clear();
 }
 
 gfx::Rect DirectRenderer::ComputeScissorRectForRenderPass(
     const DrawingFrame* frame) {
   gfx::Rect render_pass_scissor = frame->current_render_pass->output_rect;
@@ skipping 267 matching lines @@
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc