Convert //dbus from scoped_ptr to std::unique_ptr

dbus/object_proxy.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_OBJECT_PROXY_H_
 #define DBUS_OBJECT_PROXY_H_
 
 #include <dbus/dbus.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "dbus/dbus_export.h"
 #include "dbus/object_path.h"
 
 namespace dbus {
 
 class Bus;
 class ErrorResponse;
 class MethodCall;
@@ skipping 62 matching lines @@
   // - the signal name.
   // - whether it was successful or not.
   typedef base::Callback<void (const std::string&, const std::string&, bool)>
       OnConnectedCallback;
 
   // Calls the method of the remote object and blocks until the response
   // is returned. Returns NULL on error with the error details specified
   // in the |error| object.
   //
   // BLOCKING CALL.
-  virtual scoped_ptr<Response> CallMethodAndBlockWithErrorDetails(
+  virtual std::unique_ptr<Response> CallMethodAndBlockWithErrorDetails(
       MethodCall* method_call,
       int timeout_ms,
       ScopedDBusError* error);
 
   // Calls the method of the remote object and blocks until the response
   // is returned. Returns NULL on error.
   //
   // BLOCKING CALL.
-  virtual scoped_ptr<Response> CallMethodAndBlock(MethodCall* method_call,
-                                                  int timeout_ms);
+  virtual std::unique_ptr<Response> CallMethodAndBlock(MethodCall* method_call,
+                                                       int timeout_ms);
 
   // Requests to call the method of the remote object.
   //
   // |callback| will be called in the origin thread, once the method call
   // is complete. As it's called in the origin thread, |callback| can
   // safely reference objects in the origin thread (i.e. UI thread in most
   // cases). If the caller is not interested in the response from the
   // method (i.e. calling a method that does not return a value),
   // EmptyResponseCallback() can be passed to the |callback| parameter.
   //
@@ skipping 161 matching lines @@
   bool AddMatchRuleWithoutCallback(const std::string& match_rule,
                                    const std::string& absolute_signal_name);
 
   // Calls D-Bus's GetNameOwner method synchronously to update
   // |service_name_owner_| with the current owner of |service_name_|.
   //
   // BLOCKING CALL.
   void UpdateNameOwnerAndBlock();
 
   // Handles NameOwnerChanged signal from D-Bus's special message bus.
-  DBusHandlerResult HandleNameOwnerChanged(scoped_ptr<dbus::Signal> signal);
+  DBusHandlerResult HandleNameOwnerChanged(
+      std::unique_ptr<dbus::Signal> signal);
 
   // Runs |name_owner_changed_callback_|.
   void RunNameOwnerChangedCallback(const std::string& old_owner,
                                    const std::string& new_owner);
 
   // Runs |wait_for_service_to_be_available_callbacks_|.
   void RunWaitForServiceToBeAvailableCallbacks(bool service_is_available);
 
   scoped_refptr<Bus> bus_;
   std::string service_name_;
@@ skipping 19 matching lines @@
   std::string service_name_owner_;
 
   std::set<DBusPendingCall*> pending_calls_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectProxy);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_OBJECT_PROXY_H_