cc: Remove ScopedPtrVector and cc::remove_if.

cc/debug/micro_benchmark_controller.cc

 // Copyright 2013 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/debug/micro_benchmark_controller.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 19 matching lines @@
     return make_scoped_ptr(new InvalidationBenchmark(value.Pass(), callback));
   } else if (name == "rasterize_and_record_benchmark") {
     return make_scoped_ptr(
         new RasterizeAndRecordBenchmark(value.Pass(), callback));
   } else if (name == "unittest_only_benchmark") {
     return make_scoped_ptr(new UnittestOnlyBenchmark(value.Pass(), callback));
   }
   return nullptr;
 }
 
-class IsDonePredicate {
- public:
-  typedef const MicroBenchmark* argument_type;
-  typedef bool result_type;
-
-  result_type operator()(argument_type benchmark) const {
-    return benchmark->IsDone();
-  }
-};
-
 }  // namespace
 
 MicroBenchmarkController::MicroBenchmarkController(LayerTreeHost* host)
     : host_(host),
       main_controller_task_runner_(base::ThreadTaskRunnerHandle::IsSet()
                                        ? base::ThreadTaskRunnerHandle::Get()
                                        : nullptr) {
   DCHECK(host_);
 }
 
@@ skipping 18 matching lines @@
 int MicroBenchmarkController::GetNextIdAndIncrement() {
   int id = next_id_++;
   // Wrap around to 1 if we overflow (very unlikely).
   if (next_id_ == std::numeric_limits<int>::max())
     next_id_ = 1;
   return id;
 }
 
 bool MicroBenchmarkController::SendMessage(int id,
                                            scoped_ptr<base::Value> value) {
-  for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
-       it != benchmarks_.end();
-       ++it) {
-    if ((*it)->id() == id)
-      return (*it)->ProcessMessage(value.Pass());
-  }
-  return false;
+  auto it = std::find_if(benchmarks_.begin(), benchmarks_.end(),
+                         [id](const scoped_ptr<MicroBenchmark>& benchmark) {
+                           return benchmark->id() == id;
+                         });
+  if (it == benchmarks_.end())
+    return false;
+  return (*it)->ProcessMessage(std::move(value));
 }
 
 void MicroBenchmarkController::ScheduleImplBenchmarks(
     LayerTreeHostImpl* host_impl) {
-  for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
-       it != benchmarks_.end();
-       ++it) {
+  for (const auto& benchmark : benchmarks_) {
     scoped_ptr<MicroBenchmarkImpl> benchmark_impl;
-    if (!(*it)->ProcessedForBenchmarkImpl()) {
-      benchmark_impl = (*it)->GetBenchmarkImpl(main_controller_task_runner_);
+    if (!benchmark->ProcessedForBenchmarkImpl()) {
+      benchmark_impl =
+          benchmark->GetBenchmarkImpl(main_controller_task_runner_);
     }
 
     if (benchmark_impl.get())
       host_impl->ScheduleMicroBenchmark(benchmark_impl.Pass());
   }
 }
 
 void MicroBenchmarkController::DidUpdateLayers() {
-  for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
-       it != benchmarks_.end();
-       ++it) {
-    if (!(*it)->IsDone())
-      (*it)->DidUpdateLayers(host_);
+  for (const auto& benchmark : benchmarks_) {
+    if (!benchmark->IsDone())
+      benchmark->DidUpdateLayers(host_);
   }
 
   CleanUpFinishedBenchmarks();
 }
 
 void MicroBenchmarkController::CleanUpFinishedBenchmarks() {
   benchmarks_.erase(
-      benchmarks_.partition(std::not1(IsDonePredicate())),
+      std::remove_if(benchmarks_.begin(), benchmarks_.end(),
+                     [](const scoped_ptr<MicroBenchmark>& benchmark) {
+                       return benchmark->IsDone();
+                     }),
       benchmarks_.end());
 }
 
 }  // namespace cc