Convert //base to use std::unique_ptr

base/callback_list.h

 // Copyright 2013 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 BASE_CALLBACK_LIST_H_
 #define BASE_CALLBACK_LIST_H_
 
 #include <list>
+#include <memory>
 
 #include "base/callback.h"
 #include "base/callback_internal.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 
 // OVERVIEW:
 //
 // A container for a list of callbacks.  Unlike a normal STL vector or list,
 // this container can be modified during iteration without invalidating the
 // iterator. It safely handles the case of a callback removing itself
 // or another callback from the list while callbacks are being run.
 //
 // TYPICAL USAGE:
 //
 // class MyWidget {
 //  public:
 //   ...
 //
 //   typedef base::Callback<void(const Foo&)> OnFooCallback;
 //
-//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
+//   std::unique_ptr<base::CallbackList<void(const Foo&)>::Subscription>
 //   RegisterCallback(const OnFooCallback& cb) {
 //     return callback_list_.Add(cb);
 //   }
 //
 //  private:
 //   void NotifyFoo(const Foo& foo) {
 //      callback_list_.Notify(foo);
 //   }
 //
 //   base::CallbackList<void(const Foo&)> callback_list_;
@@ skipping 12 matching lines @@
 //   MyWidgetListener::~MyWidgetListener() {
 //      // Subscription gets deleted automatically and will deregister
 //      // the callback in the process.
 //   }
 //
 //  private:
 //   void OnFoo(const Foo& foo) {
 //     // Do something.
 //   }
 //
-//   scoped_ptr<base::CallbackList<void(const Foo&)>::Subscription>
+//   std::unique_ptr<base::CallbackList<void(const Foo&)>::Subscription>
 //       foo_subscription_;
 //
 //   DISALLOW_COPY_AND_ASSIGN(MyWidgetListener);
 // };
 
 namespace base {
 
 namespace internal {
 
 template <typename CallbackType>
@@ skipping 20 matching lines @@
    private:
     CallbackListBase<CallbackType>* list_;
     typename std::list<CallbackType>::iterator iter_;
 
     DISALLOW_COPY_AND_ASSIGN(Subscription);
   };
 
   // Add a callback to the list. The callback will remain registered until the
   // returned Subscription is destroyed, which must occur before the
   // CallbackList is destroyed.
-  scoped_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
+  std::unique_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
     DCHECK(!cb.is_null());
-    return scoped_ptr<Subscription>(
+    return std::unique_ptr<Subscription>(
         new Subscription(this, callbacks_.insert(callbacks_.end(), cb)));
   }
 
   // Sets a callback which will be run when a subscription list is changed.
   void set_removal_callback(const Closure& callback) {
     removal_callback_ = callback;
   }
 
   // Returns true if there are no subscriptions. This is only valid to call when
   // not looping through the list.
@@ skipping 102 matching lines @@
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackList);
 };
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_LIST_H_