Convert //dbus from scoped_ptr to std::unique_ptr

dbus/exported_object.h

 // 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.
 
 #ifndef DBUS_EXPORTED_OBJECT_H_
 #define DBUS_EXPORTED_OBJECT_H_
 
 #include <dbus/dbus.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "dbus/dbus_export.h"
 #include "dbus/object_path.h"
 
 namespace dbus {
 
 class Bus;
 class MethodCall;
 class Response;
 class Signal;
 
 // ExportedObject is used to export objects and methods to other D-Bus
 // clients.
 //
 // ExportedObject is a ref counted object, to ensure that |this| of the
 // object is alive when callbacks referencing |this| are called.
 class CHROME_DBUS_EXPORT ExportedObject
     : public base::RefCountedThreadSafe<ExportedObject> {
  public:
   // Client code should use Bus::GetExportedObject() instead of this
   // constructor.
   ExportedObject(Bus* bus, const ObjectPath& object_path);
 
   // Called to send a response from an exported method. |response| is the
   // response message. Callers should pass NULL in the event of an error that
   // prevents the sending of a response.
-  typedef base::Callback<void (scoped_ptr<Response> response)> ResponseSender;
+  typedef base::Callback<void(std::unique_ptr<Response> response)>
+      ResponseSender;
 
   // Called when an exported method is called. |method_call| is the request
   // message. |sender| is the callback that's used to send a response.
   //
   // |method_call| is owned by ExportedObject, hence client code should not
   // delete |method_call|.
   typedef base::Callback<void (MethodCall* method_call, ResponseSender sender)>
       MethodCallCallback;
 
   // Called when method exporting is done.
@@ skipping 76 matching lines @@
   // BLOCKING CALL.
   bool Register();
 
   // Handles the incoming request messages and dispatches to the exported
   // methods.
   DBusHandlerResult HandleMessage(DBusConnection* connection,
                                   DBusMessage* raw_message);
 
   // Runs the method. Helper function for HandleMessage().
   void RunMethod(MethodCallCallback method_call_callback,
-                 scoped_ptr<MethodCall> method_call,
+                 std::unique_ptr<MethodCall> method_call,
                  base::TimeTicks start_time);
 
   // Callback invoked by service provider to send a response to a method call.
   // Can be called immediately from a MethodCallCallback to implement a
   // synchronous service or called later to implement an asynchronous service.
   void 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);
 
   // Called on completion of the method run from SendResponse().
   // Takes ownership of |method_call| and |response|.
-  void OnMethodCompleted(scoped_ptr<MethodCall> method_call,
-                         scoped_ptr<Response> response,
+  void OnMethodCompleted(std::unique_ptr<MethodCall> method_call,
+                         std::unique_ptr<Response> response,
                          base::TimeTicks start_time);
 
   // Called when the object is unregistered.
   void OnUnregistered(DBusConnection* connection);
 
   // Redirects the function call to HandleMessage().
   static DBusHandlerResult HandleMessageThunk(DBusConnection* connection,
                                               DBusMessage* raw_message,
                                               void* user_data);
 
   // Redirects the function call to OnUnregistered().
   static void OnUnregisteredThunk(DBusConnection* connection,
                                   void* user_data);
 
   scoped_refptr<Bus> bus_;
   ObjectPath object_path_;
   bool object_is_registered_;
 
   // The method table where keys are absolute method names (i.e. interface
   // name + method name), and values are the corresponding callbacks.
   typedef std::map<std::string, MethodCallCallback> MethodTable;
   MethodTable method_table_;
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_EXPORTED_OBJECT_H_