cc: Remove ScopedPtrVector and cc::remove_if.

cc/trees/tree_synchronizer.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/tree_synchronizer.h"
 
 #include <set>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 
 namespace cc {
 
 typedef base::ScopedPtrHashMap<int, scoped_ptr<LayerImpl>>
     ScopedPtrLayerImplMap;
 typedef base::hash_map<int, LayerImpl*> RawPtrLayerImplMap;
 
 void CollectExistingLayerImplRecursive(ScopedPtrLayerImplMap* old_layers,
                                        scoped_ptr<LayerImpl> layer_impl) {
   if (!layer_impl)
     return;
 
   OwnedLayerImplList& children = layer_impl->children();
-  for (OwnedLayerImplList::iterator it = children.begin();
-       it != children.end();
-       ++it)
-    CollectExistingLayerImplRecursive(old_layers, children.take(it));
+  for (auto& child : children)
+    CollectExistingLayerImplRecursive(old_layers, std::move(child));
 
   CollectExistingLayerImplRecursive(old_layers, layer_impl->TakeMaskLayer());
   CollectExistingLayerImplRecursive(old_layers, layer_impl->TakeReplicaLayer());
 
   int id = layer_impl->id();
   old_layers->set(id, layer_impl.Pass());
 }
 
 template <typename LayerType>
 scoped_ptr<LayerImpl> SynchronizeTreesInternal(
@@ skipping 114 matching lines @@
                            layer_impl->mask_layer(),
                            &num_dependents_need_push_properties);
     PushPropertiesInternal(layer->replica_layer(),
                            layer_impl->replica_layer(),
                            &num_dependents_need_push_properties);
 
     const OwnedLayerImplList& impl_children = layer_impl->children();
     DCHECK_EQ(layer->children().size(), impl_children.size());
 
     for (size_t i = 0; i < layer->children().size(); ++i) {
-      PushPropertiesInternal(layer->child_at(i),
-                             impl_children[i],
+      PushPropertiesInternal(layer->child_at(i), impl_children[i].get(),
                              &num_dependents_need_push_properties);
     }
 
     // When PushPropertiesTo completes for a layer, it may still keep
     // its needs_push_properties() state if the layer must push itself
     // every PushProperties tree walk. Here we keep track of those layers, and
     // ensure that their ancestors know about them for the next PushProperties
     // tree walk.
     layer->num_dependents_need_push_properties_ =
         num_dependents_need_push_properties;
@@ skipping 70 matching lines @@
 #endif
 }
 
 void TreeSynchronizer::PushProperties(LayerImpl* layer, LayerImpl* layer_impl) {
   int num_dependents_need_push_properties = 0;
   PushPropertiesInternal(
       layer, layer_impl, &num_dependents_need_push_properties);
 }
 
 }  // namespace cc