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

content/common/gpu/image_transport_surface.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 "content/common/gpu/image_transport_surface.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 146 matching lines @@
 
 void PassThroughImageTransportSurface::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++)
     latency_info_.push_back(latency_info[i]);
 }
 
 gfx::SwapResult PassThroughImageTransportSurface::SwapBuffers() {
   scoped_ptr<std::vector<ui::LatencyInfo>> latency_info = StartSwapBuffers();
   gfx::SwapResult result = gfx::GLSurfaceAdapter::SwapBuffers();
-  FinishSwapBuffers(latency_info.Pass(), result);
+  FinishSwapBuffers(std::move(latency_info), result);
   return result;
 }
 
 void PassThroughImageTransportSurface::SwapBuffersAsync(
     const GLSurface::SwapCompletionCallback& callback) {
   scoped_ptr<std::vector<ui::LatencyInfo>> latency_info = StartSwapBuffers();
 
   // We use WeakPtr here to avoid manual management of life time of an instance
   // of this class. Callback will not be called once the instance of this class
   // is destroyed. However, this also means that the callback can be run on
   // the calling thread only.
   gfx::GLSurfaceAdapter::SwapBuffersAsync(base::Bind(
       &PassThroughImageTransportSurface::FinishSwapBuffersAsync,
       weak_ptr_factory_.GetWeakPtr(), base::Passed(&latency_info), callback));
 }
 
 gfx::SwapResult PassThroughImageTransportSurface::PostSubBuffer(int x,
                                                                 int y,
                                                                 int width,
                                                                 int height) {
   scoped_ptr<std::vector<ui::LatencyInfo>> latency_info = StartSwapBuffers();
   gfx::SwapResult result =
       gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
-  FinishSwapBuffers(latency_info.Pass(), result);
+  FinishSwapBuffers(std::move(latency_info), result);
   return result;
 }
 
 void PassThroughImageTransportSurface::PostSubBufferAsync(
     int x,
     int y,
     int width,
     int height,
     const GLSurface::SwapCompletionCallback& callback) {
   scoped_ptr<std::vector<ui::LatencyInfo>> latency_info = StartSwapBuffers();
   gfx::GLSurfaceAdapter::PostSubBufferAsync(
       x, y, width, height,
       base::Bind(&PassThroughImageTransportSurface::FinishSwapBuffersAsync,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&latency_info),
                  callback));
 }
 
 gfx::SwapResult PassThroughImageTransportSurface::CommitOverlayPlanes() {
   scoped_ptr<std::vector<ui::LatencyInfo>> latency_info = StartSwapBuffers();
   gfx::SwapResult result = gfx::GLSurfaceAdapter::CommitOverlayPlanes();
-  FinishSwapBuffers(latency_info.Pass(), result);
+  FinishSwapBuffers(std::move(latency_info), result);
   return result;
 }
 
 void PassThroughImageTransportSurface::CommitOverlayPlanesAsync(
     const GLSurface::SwapCompletionCallback& callback) {
   scoped_ptr<std::vector<ui::LatencyInfo>> latency_info = StartSwapBuffers();
   gfx::GLSurfaceAdapter::CommitOverlayPlanesAsync(base::Bind(
       &PassThroughImageTransportSurface::FinishSwapBuffersAsync,
       weak_ptr_factory_.GetWeakPtr(), base::Passed(&latency_info), callback));
 }
@@ skipping 57 matching lines @@
         swap_ack_time, 1);
   }
 
   helper_->stub()->SendSwapBuffersCompleted(*latency_info, result);
 }
 
 void PassThroughImageTransportSurface::FinishSwapBuffersAsync(
     scoped_ptr<std::vector<ui::LatencyInfo>> latency_info,
     GLSurface::SwapCompletionCallback callback,
     gfx::SwapResult result) {
-  FinishSwapBuffers(latency_info.Pass(), result);
+  FinishSwapBuffers(std::move(latency_info), result);
   callback.Run(result);
 }
 
 }  // namespace content