Remove the TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03 macro.

mojo/edk/system/shared_buffer_dispatcher.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/edk/system/shared_buffer_dispatcher.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/options_validation.h"
 #include "mojo/public/c/system/macros.h"
 
 namespace mojo {
@@ skipping 51 matching lines @@
   if (!num_bytes)
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (num_bytes > GetConfiguration().max_shared_memory_num_bytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   scoped_refptr<PlatformSharedBuffer> shared_buffer(
       platform_support->CreateSharedBuffer(static_cast<size_t>(num_bytes)));
   if (!shared_buffer)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
-  *result = CreateInternal(shared_buffer.Pass());
+  *result = CreateInternal(std::move(shared_buffer));
   return MOJO_RESULT_OK;
 }
 
 Dispatcher::Type SharedBufferDispatcher::GetType() const {
   return Type::SHARED_BUFFER;
 }
 
 // static
 scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
     const void* source,
@@ skipping 32 matching lines @@
   // closed even if creation fails.
   scoped_refptr<PlatformSharedBuffer> shared_buffer(
       internal::g_platform_support->CreateSharedBufferFromHandle(
           num_bytes, ScopedPlatformHandle(platform_handle)));
   if (!shared_buffer) {
     LOG(ERROR)
         << "Invalid serialized shared buffer dispatcher (invalid num_bytes?)";
     return nullptr;
   }
 
-  return CreateInternal(shared_buffer.Pass());
+  return CreateInternal(std::move(shared_buffer));
 }
 
 SharedBufferDispatcher::SharedBufferDispatcher(
     scoped_refptr<PlatformSharedBuffer> shared_buffer)
     : shared_buffer_(shared_buffer) {
   DCHECK(shared_buffer_);
 }
 
 SharedBufferDispatcher::~SharedBufferDispatcher() {
 }
@@ skipping 33 matching lines @@
 void SharedBufferDispatcher::CloseImplNoLock() {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
   shared_buffer_ = nullptr;
 }
 
 scoped_refptr<Dispatcher>
 SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
-  return CreateInternal(shared_buffer_.Pass());
+  return CreateInternal(std::move(shared_buffer_));
 }
 
 MojoResult SharedBufferDispatcher::DuplicateBufferHandleImplNoLock(
     const MojoDuplicateBufferHandleOptions* options,
     scoped_refptr<Dispatcher>* new_dispatcher) {
   lock().AssertAcquired();
 
   MojoDuplicateBufferHandleOptions validated_options;
   MojoResult result = ValidateDuplicateOptions(options, &validated_options);
   if (result != MOJO_RESULT_OK)
@@ skipping 62 matching lines @@
   *actual_size = sizeof(SerializedSharedBufferDispatcher);
 
   shared_buffer_ = nullptr;
 
   return true;
 }
 
 
 }  // namespace edk
 }  // namespace mojo