cc: Remove ScopedPtrVector and cc::remove_if.

cc/layers/heads_up_display_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/heads_up_display_layer_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/numerics/safe_conversions.h"
@@ skipping 73 matching lines @@
 
 HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() {}
 
 scoped_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return HeadsUpDisplayLayerImpl::Create(tree_impl, id());
 }
 
 void HeadsUpDisplayLayerImpl::AcquireResource(
     ResourceProvider* resource_provider) {
-  for (ScopedPtrVector<ScopedResource>::iterator it = resources_.begin();
-       it != resources_.end();
-       ++it) {
-    if (!resource_provider->InUseByConsumer((*it)->id())) {
-      resources_.swap(it, resources_.end() - 1);
+  for (auto& resource : resources_) {
+    if (!resource_provider->InUseByConsumer(resource->id())) {
+      resource.swap(resources_.back());
       return;
     }
   }
 
   scoped_ptr<ScopedResource> resource =
       ScopedResource::Create(resource_provider);
   resource->Allocate(internal_content_bounds_,
                      ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                      resource_provider->best_texture_format());
   resources_.push_back(resource.Pass());
 }
 
-class ResourceSizeIsEqualTo {
- public:
-  explicit ResourceSizeIsEqualTo(const gfx::Size& size_)
-      : compare_size_(size_) {}
-
-  bool operator()(const ScopedResource* resource) {
-    return resource->size() == compare_size_;
-  }
-
- private:
-  const gfx::Size compare_size_;
-};
-
 void HeadsUpDisplayLayerImpl::ReleaseUnmatchedSizeResources(
     ResourceProvider* resource_provider) {
-  ScopedPtrVector<ScopedResource>::iterator it_erase =
-      resources_.partition(ResourceSizeIsEqualTo(internal_content_bounds_));
+  auto it_erase =
+      std::remove_if(resources_.begin(), resources_.end(),
+                     [this](const scoped_ptr<ScopedResource>& resource) {
+                       return internal_content_bounds_ != resource->size();
+                     });
   resources_.erase(it_erase, resources_.end());
 }
 
 bool HeadsUpDisplayLayerImpl::WillDraw(DrawMode draw_mode,
                                        ResourceProvider* resource_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
 
   internal_contents_scale_ = GetIdealContentsScale();
   internal_content_bounds_ =
@@ skipping 665 matching lines @@
   return "cc::HeadsUpDisplayLayerImpl";
 }
 
 void HeadsUpDisplayLayerImpl::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   LayerImpl::AsValueInto(dict);
   dict->SetString("layer_name", "Heads Up Display Layer");
 }
 
 }  // namespace cc