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

dbus/test_service.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/test_service.h"
 
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/bus.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 #include "dbus/object_manager.h"
 #include "dbus/object_path.h"
@@ skipping 284 matching lines @@
   MessageReader reader(method_call);
   std::string text_message;
   if (!reader.PopString(&text_message)) {
     response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
   MessageWriter writer(response.get());
   writer.AppendString(text_message);
-  response_sender.Run(response.Pass());
+  response_sender.Run(std::move(response));
 }
 
 void TestService::SlowEcho(MethodCall* method_call,
                            ExportedObject::ResponseSender response_sender) {
   base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   Echo(method_call, response_sender);
 }
 
 void TestService::AsyncEcho(MethodCall* method_call,
                             ExportedObject::ResponseSender response_sender) {
@@ skipping 20 matching lines @@
   if (!reader.PopString(&interface)) {
     response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
   MessageWriter writer(response.get());
 
   AddPropertiesToWriter(&writer);
 
-  response_sender.Run(response.Pass());
+  response_sender.Run(std::move(response));
 }
 
 void TestService::GetProperty(MethodCall* method_call,
                               ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
   std::string interface;
   if (!reader.PopString(&interface)) {
     response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   std::string name;
   if (!reader.PopString(&name)) {
     response_sender.Run(scoped_ptr<Response>());
     return;
   }
 
   if (name == "Name") {
     // Return the previous value for the "Name" property:
     // Variant<"TestService">
     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
     MessageWriter writer(response.get());
 
     writer.AppendVariantOfString("TestService");
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   } else if (name == "Version") {
     // Return a new value for the "Version" property:
     // Variant<20>
     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
     MessageWriter writer(response.get());
 
     writer.AppendVariantOfInt16(20);
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   } else if (name == "Methods") {
     // Return the previous value for the "Methods" property:
     // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>
     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
     MessageWriter writer(response.get());
     MessageWriter variant_writer(NULL);
     MessageWriter variant_array_writer(NULL);
 
     writer.OpenVariant("as", &variant_writer);
     variant_writer.OpenArray("s", &variant_array_writer);
     variant_array_writer.AppendString("Echo");
     variant_array_writer.AppendString("SlowEcho");
     variant_array_writer.AppendString("AsyncEcho");
     variant_array_writer.AppendString("BrokenMethod");
     variant_writer.CloseContainer(&variant_array_writer);
     writer.CloseContainer(&variant_writer);
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   } else if (name == "Objects") {
     // Return the previous value for the "Objects" property:
     // Variant<[objectpath:"/TestObjectPath"]>
     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
     MessageWriter writer(response.get());
     MessageWriter variant_writer(NULL);
     MessageWriter variant_array_writer(NULL);
 
     writer.OpenVariant("ao", &variant_writer);
     variant_writer.OpenArray("o", &variant_array_writer);
     variant_array_writer.AppendObjectPath(ObjectPath("/TestObjectPath"));
     variant_writer.CloseContainer(&variant_array_writer);
     writer.CloseContainer(&variant_writer);
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   } else if (name == "Bytes") {
     // Return the previous value for the "Bytes" property:
     // Variant<[0x54, 0x65, 0x73, 0x74]>
     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
     MessageWriter writer(response.get());
     MessageWriter variant_writer(NULL);
     MessageWriter variant_array_writer(NULL);
 
     writer.OpenVariant("ay", &variant_writer);
     const uint8_t bytes[] = {0x54, 0x65, 0x73, 0x74};
     variant_writer.AppendArrayOfBytes(bytes, sizeof(bytes));
     writer.CloseContainer(&variant_writer);
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   } else {
     // Return error.
     response_sender.Run(scoped_ptr<Response>());
     return;
   }
 }
 
 void TestService::SetProperty(MethodCall* method_call,
                               ExportedObject::ResponseSender response_sender) {
   MessageReader reader(method_call);
@@ skipping 50 matching lines @@
   } else if (action == "Ownership") {
     ReleaseOwnership(base::Bind(&TestService::OwnershipReleased,
                                 base::Unretained(this),
                                 method_call, response_sender));
     return;
   } else if (action == "InvalidateProperty") {
     SendPropertyInvalidatedSignal();
   }
 
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
-  response_sender.Run(response.Pass());
+  response_sender.Run(std::move(response));
 }
 
 void TestService::PerformActionResponse(
     MethodCall* method_call,
     ExportedObject::ResponseSender response_sender) {
   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
-  response_sender.Run(response.Pass());
+  response_sender.Run(std::move(response));
 }
 
 void TestService::OwnershipReleased(
     MethodCall* method_call,
     ExportedObject::ResponseSender response_sender) {
   RequestOwnership(base::Bind(&TestService::OwnershipRegained,
                               base::Unretained(this),
                               method_call, response_sender));
 }
 
@@ skipping 39 matching lines @@
   object_array_writer.OpenDictEntry(&object_dict_entry_writer);
   object_dict_entry_writer.AppendString("org.chromium.TestInterface");
   AddPropertiesToWriter(&object_dict_entry_writer);
   object_array_writer.CloseContainer(&object_dict_entry_writer);
 
   dict_entry_writer.CloseContainer(&object_array_writer);
 
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
-  response_sender.Run(response.Pass());
+  response_sender.Run(std::move(response));
 
   if (send_immediate_properties_changed_)
     SendPropertyChangedSignal("ChangedTestServiceName");
 }
 
 void TestService::AddPropertiesToWriter(MessageWriter* writer) {
   // The properties response is a dictionary of strings identifying the
   // property and a variant containing the property value. We return all
   // of the properties, thus the response is:
   //
@@ skipping 151 matching lines @@
   MessageWriter invalidated_array_writer(NULL);
 
   writer.OpenArray("s", &invalidated_array_writer);
   invalidated_array_writer.AppendString("Name");
   writer.CloseContainer(&invalidated_array_writer);
 
   exported_object_->SendSignal(&signal);
 }
 
 }  // namespace dbus