Convert //dbus from scoped_ptr to std::unique_ptr

dbus/exported_object.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/exported_object.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 177 matching lines @@
 
 DBusHandlerResult ExportedObject::HandleMessage(
     DBusConnection* connection,
     DBusMessage* raw_message) {
   bus_->AssertOnDBusThread();
   DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_CALL, dbus_message_get_type(raw_message));
 
   // raw_message will be unrefed on exit of the function. Increment the
   // reference so we can use it in MethodCall.
   dbus_message_ref(raw_message);
-  scoped_ptr<MethodCall> method_call(
+  std::unique_ptr<MethodCall> method_call(
       MethodCall::FromRawMessage(raw_message));
   const std::string interface = method_call->GetInterface();
   const std::string member = method_call->GetMember();
 
   if (interface.empty()) {
     // We don't support method calls without interface.
     LOG(WARNING) << "Interface is missing: " << method_call->ToString();
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
 
@@ skipping 25 matching lines @@
                                 start_time,
                                 base::Passed(&method_call)));
   }
 
   // It's valid to say HANDLED here, and send a method response at a later
   // time from OnMethodCompleted() asynchronously.
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 void ExportedObject::RunMethod(MethodCallCallback method_call_callback,
-                               scoped_ptr<MethodCall> method_call,
+                               std::unique_ptr<MethodCall> method_call,
                                base::TimeTicks start_time) {
   bus_->AssertOnOriginThread();
   MethodCall* method = method_call.get();
   method_call_callback.Run(method,
                            base::Bind(&ExportedObject::SendResponse,
                                       this,
                                       start_time,
                                       base::Passed(&method_call)));
 }
 
 void ExportedObject::SendResponse(base::TimeTicks start_time,
-                                  scoped_ptr<MethodCall> method_call,
-                                  scoped_ptr<Response> response) {
+                                  std::unique_ptr<MethodCall> method_call,
+                                  std::unique_ptr<Response> response) {
   DCHECK(method_call);
   if (bus_->HasDBusThread()) {
     bus_->GetDBusTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ExportedObject::OnMethodCompleted,
                    this,
                    base::Passed(&method_call),
                    base::Passed(&response),
                    start_time));
   } else {
     OnMethodCompleted(std::move(method_call), std::move(response), start_time);
   }
 }
 
-void ExportedObject::OnMethodCompleted(scoped_ptr<MethodCall> method_call,
-                                       scoped_ptr<Response> response,
+void ExportedObject::OnMethodCompleted(std::unique_ptr<MethodCall> method_call,
+                                       std::unique_ptr<Response> response,
                                        base::TimeTicks start_time) {
   bus_->AssertOnDBusThread();
 
   // Record if the method call is successful, or not. 1 if successful.
   UMA_HISTOGRAM_ENUMERATION("DBus.ExportedMethodHandleSuccess",
                             response ? 1 : 0,
                             kSuccessRatioHistogramMaxValue);
 
   // Check if the bus is still connected. If the method takes long to
   // complete, the bus may be shut down meanwhile.
   if (!bus_->is_connected())
     return;
 
   if (!response) {
     // Something bad happened in the method call.
-    scoped_ptr<ErrorResponse> error_response(
-        ErrorResponse::FromMethodCall(
-            method_call.get(),
-            DBUS_ERROR_FAILED,
-            "error occurred in " + method_call->GetMember()));
+    std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall(
+        method_call.get(), DBUS_ERROR_FAILED,
+        "error occurred in " + method_call->GetMember()));
     bus_->Send(error_response->raw_message(), NULL);
     return;
   }
 
   // The method call was successful.
   bus_->Send(response->raw_message(), NULL);
 
   // Record time spent to handle the the method call. Don't include failures.
   UMA_HISTOGRAM_TIMES("DBus.ExportedMethodHandleTime",
                       base::TimeTicks::Now() - start_time);
@@ skipping 10 matching lines @@
   return self->HandleMessage(connection, raw_message);
 }
 
 void ExportedObject::OnUnregisteredThunk(DBusConnection *connection,
                                          void* user_data) {
   ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data);
   return self->OnUnregistered(connection);
 }
 
 }  // namespace dbus