Convert Pass()→std::move() in ui/

ui/compositor/layer.cc

 // Copyright (c) 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 "ui/compositor/layer.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/layer_settings.h"
@@ skipping 338 matching lines @@
 }
 
 void Layer::SetBackgroundZoom(float zoom, int inset) {
   zoom_ = zoom;
   zoom_inset_ = inset;
 
   SetLayerBackgroundFilters();
 }
 
 void Layer::SetAlphaShape(scoped_ptr<SkRegion> region) {
-  alpha_shape_ = region.Pass();
+  alpha_shape_ = std::move(region);
 
   SetLayerFilters();
 }
 
 void Layer::SetLayerFilters() {
   cc::FilterOperations filters;
   if (layer_saturation_) {
     filters.Append(cc::FilterOperation::CreateSaturateFilter(
         layer_saturation_));
   }
@@ skipping 168 matching lines @@
         cc::TextureLayer::CreateForMailbox(UILayerSettings(), this);
     new_layer->SetFlipped(true);
     SwitchToLayer(new_layer);
     texture_layer_ = new_layer;
     // Reset the frame_size_in_dip_ so that SetTextureSize() will not early out,
     // the frame_size_in_dip_ was for a previous (different) |texture_layer_|.
     frame_size_in_dip_ = gfx::Size();
   }
   if (mailbox_release_callback_)
     mailbox_release_callback_->Run(gpu::SyncToken(), false);
-  mailbox_release_callback_ = release_callback.Pass();
+  mailbox_release_callback_ = std::move(release_callback);
   mailbox_ = mailbox;
   SetTextureSize(texture_size_in_dip);
 }
 
 void Layer::SetTextureSize(gfx::Size texture_size_in_dip) {
   DCHECK(texture_layer_.get());
   if (frame_size_in_dip_ == texture_size_in_dip)
     return;
   frame_size_in_dip_ = texture_size_in_dip;
   RecomputeDrawsContentAndUVRect();
@@ skipping 172 matching lines @@
 }
 
 void Layer::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
   DCHECK(delegated_renderer_layer_.get() || surface_layer_.get());
   if (!delegate_)
     return;
   delegate_->OnDelegatedFrameDamage(damage_rect_in_dip);
 }
 
 void Layer::RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request) {
-  cc_layer_->RequestCopyOfOutput(request.Pass());
+  cc_layer_->RequestCopyOfOutput(std::move(request));
 }
 
 gfx::Rect Layer::PaintableRegion() {
   return gfx::Rect(size());
 }
 
 scoped_refptr<cc::DisplayItemList> Layer::PaintContentsToDisplayList(
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContentsToDisplayList", "name", name_);
   gfx::Rect local_bounds(bounds().size());
@@ skipping 20 matching lines @@
   return 0;
 }
 
 bool Layer::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!mailbox_release_callback_)
     return false;
   *mailbox = mailbox_;
-  *release_callback = mailbox_release_callback_.Pass();
+  *release_callback = std::move(mailbox_release_callback_);
   return true;
 }
 
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == force)
     return;
 
   force_render_surface_ = force;
   cc_layer_->SetForceRenderSurface(force_render_surface_);
 }
@@ skipping 166 matching lines @@
 
 float Layer::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
   DCHECK(cc_layer_);
   // Until this layer has a compositor (and hence cc_layer_ has a
   // LayerTreeHost), addAnimation will fail.
   if (GetCompositor())
-    cc_layer_->AddAnimation(animation.Pass());
+    cc_layer_->AddAnimation(std::move(animation));
   else
-    pending_threaded_animations_.push_back(animation.Pass());
+    pending_threaded_animations_.push_back(std::move(animation));
 }
 
 void Layer::RemoveThreadedAnimation(int animation_id) {
   DCHECK(cc_layer_);
   if (pending_threaded_animations_.size() == 0) {
     cc_layer_->RemoveAnimation(animation_id);
     return;
   }
 
   pending_threaded_animations_.erase(
@@ skipping 83 matching lines @@
     animator_->RemoveFromCollection(collection);
   for (auto* child : children_)
     child->RemoveAnimatorsInTreeFromCollection(collection);
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui