cc: Replace Pass() with std::move() in some subdirs.

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"
@@ skipping 14 matching lines @@
     return;
 
   OwnedLayerImplList& children = layer_impl->children();
   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());
+  old_layers->set(id, std::move(layer_impl));
 }
 
 template <typename LayerType>
 scoped_ptr<LayerImpl> SynchronizeTreesInternal(
     LayerType* layer_root,
     scoped_ptr<LayerImpl> old_layer_impl_root,
     LayerTreeImpl* tree_impl) {
   DCHECK(tree_impl);
 
   TRACE_EVENT0("cc", "TreeSynchronizer::SynchronizeTrees");
   ScopedPtrLayerImplMap old_layers;
   RawPtrLayerImplMap new_layers;
 
-  CollectExistingLayerImplRecursive(&old_layers, old_layer_impl_root.Pass());
+  CollectExistingLayerImplRecursive(&old_layers,
+                                    std::move(old_layer_impl_root));
 
   scoped_ptr<LayerImpl> new_tree = SynchronizeTreesRecursive(
       &new_layers, &old_layers, layer_root, tree_impl);
 
-  return new_tree.Pass();
+  return new_tree;
 }
 
 scoped_ptr<LayerImpl> TreeSynchronizer::SynchronizeTrees(
     Layer* layer_root,
     scoped_ptr<LayerImpl> old_layer_impl_root,
     LayerTreeImpl* tree_impl) {
-  return SynchronizeTreesInternal(
-      layer_root, old_layer_impl_root.Pass(), tree_impl);
+  return SynchronizeTreesInternal(layer_root, std::move(old_layer_impl_root),
+                                  tree_impl);
 }
 
 scoped_ptr<LayerImpl> TreeSynchronizer::SynchronizeTrees(
     LayerImpl* layer_root,
     scoped_ptr<LayerImpl> old_layer_impl_root,
     LayerTreeImpl* tree_impl) {
-  return SynchronizeTreesInternal(
-      layer_root, old_layer_impl_root.Pass(), tree_impl);
+  return SynchronizeTreesInternal(layer_root, std::move(old_layer_impl_root),
+                                  tree_impl);
 }
 
 template <typename LayerType>
 scoped_ptr<LayerImpl> ReuseOrCreateLayerImpl(RawPtrLayerImplMap* new_layers,
                                              ScopedPtrLayerImplMap* old_layers,
                                              LayerType* layer,
                                              LayerTreeImpl* tree_impl) {
   scoped_ptr<LayerImpl> layer_impl = old_layers->take(layer->id());
 
   if (!layer_impl)
     layer_impl = layer->CreateLayerImpl(tree_impl);
 
   (*new_layers)[layer->id()] = layer_impl.get();
-  return layer_impl.Pass();
+  return layer_impl;
 }
 
 template <typename LayerType>
 scoped_ptr<LayerImpl> SynchronizeTreesRecursiveInternal(
     RawPtrLayerImplMap* new_layers,
     ScopedPtrLayerImplMap* old_layers,
     LayerType* layer,
     LayerTreeImpl* tree_impl) {
   if (!layer)
     return nullptr;
 
   scoped_ptr<LayerImpl> layer_impl =
       ReuseOrCreateLayerImpl(new_layers, old_layers, layer, tree_impl);
 
   layer_impl->ClearChildList();
   for (size_t i = 0; i < layer->children().size(); ++i) {
     layer_impl->AddChild(SynchronizeTreesRecursiveInternal(
         new_layers, old_layers, layer->child_at(i), tree_impl));
   }
 
   layer_impl->SetMaskLayer(SynchronizeTreesRecursiveInternal(
       new_layers, old_layers, layer->mask_layer(), tree_impl));
   layer_impl->SetReplicaLayer(SynchronizeTreesRecursiveInternal(
       new_layers, old_layers, layer->replica_layer(), tree_impl));
 
-  return layer_impl.Pass();
+  return layer_impl;
 }
 
 scoped_ptr<LayerImpl> SynchronizeTreesRecursive(
     RawPtrLayerImplMap* new_layers,
     ScopedPtrLayerImplMap* old_layers,
     Layer* layer,
     LayerTreeImpl* tree_impl) {
   return SynchronizeTreesRecursiveInternal(
       new_layers, old_layers, layer, tree_impl);
 }
@@ skipping 124 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