Global conversion of Pass()→std::move() on Linux

dbus/message.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 "dbus/message.h"
 
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 386 matching lines @@
 
 Response::Response() : Message() {
 }
 
 scoped_ptr<Response> Response::FromRawMessage(DBusMessage* raw_message) {
   DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_RETURN,
             dbus_message_get_type(raw_message));
 
   scoped_ptr<Response> response(new Response);
   response->Init(raw_message);
-  return response.Pass();
+  return response;
 }
 
 scoped_ptr<Response> Response::FromMethodCall(MethodCall* method_call) {
   scoped_ptr<Response> response(new Response);
   response->Init(dbus_message_new_method_return(method_call->raw_message()));
-  return response.Pass();
+  return response;
 }
 
 scoped_ptr<Response> Response::CreateEmpty() {
   scoped_ptr<Response> response(new Response);
   response->Init(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN));
-  return response.Pass();
+  return response;
 }
 
 //
 // ErrorResponse implementation.
 //
 
 ErrorResponse::ErrorResponse() : Response() {
 }
 
 scoped_ptr<ErrorResponse> ErrorResponse::FromRawMessage(
     DBusMessage* raw_message) {
   DCHECK_EQ(DBUS_MESSAGE_TYPE_ERROR, dbus_message_get_type(raw_message));
 
   scoped_ptr<ErrorResponse> response(new ErrorResponse);
   response->Init(raw_message);
-  return response.Pass();
+  return response;
 }
 
 scoped_ptr<ErrorResponse> ErrorResponse::FromMethodCall(
     MethodCall* method_call,
     const std::string& error_name,
     const std::string& error_message) {
   scoped_ptr<ErrorResponse> response(new ErrorResponse);
   response->Init(dbus_message_new_error(method_call->raw_message(),
                                         error_name.c_str(),
                                         error_message.c_str()));
-  return response.Pass();
+  return response;
 }
 
 //
 // MessageWriter implementation.
 //
 
 MessageWriter::MessageWriter(Message* message)
     : message_(message),
       container_is_open_(false) {
   memset(&raw_message_iter_, 0, sizeof(raw_message_iter_));
@@ skipping 534 matching lines @@
   const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd);
   if (!success)
     return false;
 
   value->PutValue(fd);
   // NB: the caller must check validity before using the value
   return true;
 }
 
 }  // namespace dbus