Convert Pass()→std::move() in //content/browser

content/browser/web_contents/aura/overscroll_navigation_overlay.cc

 // Copyright 2014 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 "content/browser/web_contents/aura/overscroll_navigation_overlay.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/aura/overscroll_window_delegate.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
@@ skipping 29 matching lines @@
 }
 
 }  // namespace
 
 // Responsible for fading out and deleting the layer of the overlay window.
 class OverlayDismissAnimator
     : public ui::LayerAnimationObserver {
  public:
   // Takes ownership of the layer.
   explicit OverlayDismissAnimator(scoped_ptr<ui::Layer> layer)
-      : layer_(layer.Pass()) {
+      : layer_(std::move(layer)) {
     CHECK(layer_.get());
   }
 
   // Starts the fadeout animation on the layer. When the animation finishes,
   // the object deletes itself along with the layer.
   void Animate() {
     DCHECK(layer_.get());
     ui::LayerAnimator* animator = layer_->GetAnimator();
     // This makes SetOpacity() animate with default duration (which could be
     // zero, e.g. when running tests).
@@ skipping 60 matching lines @@
   // If an overscroll gesture is in progress, then do not destroy the window.
   if (!window_ || !(loading_complete_ || received_paint_update_) ||
       owa_->is_active()) {
     return;
   }
 
   // OverlayDismissAnimator deletes the dismiss layer and itself when the
   // animation completes.
   scoped_ptr<ui::Layer> dismiss_layer = window_->AcquireLayer();
   window_.reset();
-  (new OverlayDismissAnimator(dismiss_layer.Pass()))->Animate();
+  (new OverlayDismissAnimator(std::move(dismiss_layer)))->Animate();
   Observe(nullptr);
   received_paint_update_ = false;
   loading_complete_ = false;
 }
 
 scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateOverlayWindow(
     const gfx::Rect& bounds) {
   UMA_HISTOGRAM_ENUMERATION(
       "Overscroll.Started2", direction_, NAVIGATION_COUNT);
   OverscrollWindowDelegate* overscroll_delegate = new OverscrollWindowDelegate(
       owa_.get(), GetImageForDirection(direction_));
   scoped_ptr<aura::Window> window(new aura::Window(overscroll_delegate));
   window->set_owned_by_parent(false);
   window->SetTransparent(true);
   window->Init(ui::LAYER_TEXTURED);
   window->layer()->SetMasksToBounds(false);
   window->SetName("OverscrollOverlay");
   web_contents_window_->AddChild(window.get());
   aura::Window* event_window = GetMainWindow();
   if (direction_ == FORWARD)
     web_contents_window_->StackChildAbove(window.get(), event_window);
   else
     web_contents_window_->StackChildBelow(window.get(), event_window);
   window->SetBounds(bounds);
   // Set capture on the window that is receiving the overscroll events so that
   // trackpad scroll gestures keep targetting it even if the mouse pointer moves
   // off its bounds.
   event_window->SetCapture();
   window->Show();
-  return window.Pass();
+  return window;
 }
 
 const gfx::Image OverscrollNavigationOverlay::GetImageForDirection(
     NavigationDirection direction) const {
   const NavigationControllerImpl& controller = web_contents_->GetController();
   const NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
       controller.GetEntryAtOffset(direction == FORWARD ? 1 : -1));
 
   if (entry && entry->screenshot().get()) {
     std::vector<gfx::ImagePNGRep> image_reps;
@@ skipping 62 matching lines @@
     loading_complete_ = true;
   }
 
   if (navigated) {
     UMA_HISTOGRAM_ENUMERATION(
         "Overscroll.Navigated2", direction_, NAVIGATION_COUNT);
     StartObserving();
   }
 
   main_window->SetTransform(gfx::Transform());
-  window_ = window.Pass();
+  window_ = std::move(window);
   // Make sure the window is in its default position.
   window_->SetBounds(gfx::Rect(web_contents_window_->bounds().size()));
   window_->SetTransform(gfx::Transform());
   // Make sure the overlay window is on top.
   web_contents_window_->StackChildAtTop(window_.get());
   direction_ = NONE;
   StopObservingIfDone();
 }
 
 void OverscrollNavigationOverlay::OnOverscrollCancelled() {
@@ skipping 19 matching lines @@
 
 void OverscrollNavigationOverlay::DidStopLoading() {
   // Don't compare URLs in this case - it's possible they won't match if
   // a gesture-nav initiated navigation was interrupted by some other in-site
   // navigation (e.g., from a script, or from a bookmark).
   loading_complete_ = true;
   StopObservingIfDone();
 }
 
 }  // namespace content