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

mojo/gles2/command_buffer_client_impl.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 "mojo/gles2/command_buffer_client_impl.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
 #include "components/mus/gles2/mojo_buffer_backing.h"
 #include "components/mus/gles2/mojo_gpu_memory_buffer.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
@@ skipping 46 matching lines @@
       observer_binding_(this),
       command_buffer_id_(0),
       shared_state_(NULL),
       last_put_offset_(-1),
       next_transfer_buffer_id_(0),
       next_image_id_(0),
       next_fence_sync_release_(1),
       flushed_fence_sync_release_(0),
       async_waiter_(async_waiter) {
   command_buffer_.Bind(mojo::InterfacePtrInfo<mus::mojom::CommandBuffer>(
-                           command_buffer_handle.Pass(), 0u),
+                           std::move(command_buffer_handle), 0u),
                        async_waiter);
   command_buffer_.set_connection_error_handler(
       [this]() { DidLoseContext(gpu::error::kUnknown); });
 }
 
 CommandBufferClientImpl::~CommandBufferClientImpl() {}
 
 bool CommandBufferClientImpl::Initialize() {
   const size_t kSharedStateSize = sizeof(gpu::CommandBufferSharedState);
   void* memory = NULL;
   mojo::ScopedSharedBufferHandle duped;
   bool result = CreateMapAndDupSharedBuffer(
       kSharedStateSize, &memory, &shared_state_handle_, &duped);
   if (!result)
     return false;
 
   shared_state_ = static_cast<gpu::CommandBufferSharedState*>(memory);
 
   shared_state()->Initialize();
 
   mus::mojom::CommandBufferLostContextObserverPtr observer_ptr;
   observer_binding_.Bind(GetProxy(&observer_ptr), async_waiter_);
   mus::mojom::CommandBufferInfoPtr info;
   command_buffer_->Initialize(
-      observer_ptr.Pass(), duped.Pass(), mojo::Array<int32_t>::From(attribs_),
+      std::move(observer_ptr), std::move(duped),
+      mojo::Array<int32_t>::From(attribs_),
       base::Bind(&Copy<mus::mojom::CommandBufferInfoPtr>, &info));
 
   base::ThreadRestrictions::ScopedAllowWait wait;
   if (!command_buffer_.WaitForIncomingResponse()) {
     VLOG(1) << "Channel encountered error while creating command buffer.";
     return false;
   }
 
   if (!info) {
     VLOG(1) << "Command buffer cannot be initialized successfully.";
@@ skipping 62 matching lines @@
   mojo::ScopedSharedBufferHandle handle;
   mojo::ScopedSharedBufferHandle duped;
   if (!CreateMapAndDupSharedBuffer(size, &memory, &handle, &duped)) {
     if (last_state_.error == gpu::error::kNoError)
       last_state_.error = gpu::error::kLostContext;
     return NULL;
   }
 
   *id = ++next_transfer_buffer_id_;
 
-  command_buffer_->RegisterTransferBuffer(
-      *id, duped.Pass(), static_cast<uint32_t>(size));
+  command_buffer_->RegisterTransferBuffer(*id, std::move(duped),
+                                          static_cast<uint32_t>(size));
 
   scoped_ptr<gpu::BufferBacking> backing(
-      new mus::MojoBufferBacking(handle.Pass(), memory, size));
-  scoped_refptr<gpu::Buffer> buffer(new gpu::Buffer(backing.Pass()));
+      new mus::MojoBufferBacking(std::move(handle), memory, size));
+  scoped_refptr<gpu::Buffer> buffer(new gpu::Buffer(std::move(backing)));
   return buffer;
 }
 
 void CommandBufferClientImpl::DestroyTransferBuffer(int32 id) {
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities CommandBufferClientImpl::GetCapabilities() {
   return capabilities_;
 }
@@ skipping 30 matching lines @@
   MojoHandle mojo_handle = MOJO_HANDLE_INVALID;
   MojoResult create_result = MojoCreatePlatformHandleWrapper(
       platform_handle, &mojo_handle);
   if (create_result != MOJO_RESULT_OK) {
     NOTIMPLEMENTED();
     return -1;
   }
   mojo::ScopedHandle scoped_handle;
   scoped_handle.reset(mojo::Handle(mojo_handle));
   command_buffer_->CreateImage(
-      new_id, scoped_handle.Pass(), handle.type, size.Pass(),
+      new_id, std::move(scoped_handle), handle.type, std::move(size),
       static_cast<int32_t>(gpu_memory_buffer->GetFormat()), internalformat);
   if (requires_sync_point) {
     NOTIMPLEMENTED();
     // TODO(jam): need to support this if we support types other than
     // SHARED_MEMORY_BUFFER.
     //gpu_memory_buffer_manager->SetDestructionSyncPoint(gpu_memory_buffer,
     //                                                   InsertSyncPoint());
   }
 
   return new_id;
@@ skipping 137 matching lines @@
 
   // It is also safe to wait on the same context.
   if (sync_token->namespace_id() == gpu::CommandBufferNamespace::MOJO &&
       sync_token->command_buffer_id() == GetCommandBufferID())
     return true;
 
   return false;
 }
 
 }  // namespace gles2