Convert //ppapi to use std::unique_ptr

ppapi/shared_impl/proxy_lock.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 PPAPI_SHARED_IMPL_PROXY_LOCK_H_
 #define PPAPI_SHARED_IMPL_PROXY_LOCK_H_
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "ppapi/shared_impl/ppapi_shared_export.h"
 
 namespace base {
 class Lock;
 }
 
 namespace content {
 class HostGlobals;
 }
@@ skipping 154 matching lines @@
 template <>
 class RunWhileLockedHelper<void()> {
  public:
   typedef base::Callback<void()> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     // CallWhileLocked and destruction might happen on a different thread from
     // creation.
     thread_checker_.DetachFromThread();
   }
-  static void CallWhileLocked(scoped_ptr<RunWhileLockedHelper> ptr) {
+  static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr) {
     // Bind thread_checker_ to this thread so we can check in the destructor.
     // *If* the callback gets invoked, it's important that RunWhileLockedHelper
     // is destroyed on the same thread (see the comments in the destructor).
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       // Use a scope and local Callback to ensure that the callback is cleared
       // before the lock is released, even in the unlikely event that Run()
       // throws an exception.
-      scoped_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
+      std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run();
     }
   }
 
   ~RunWhileLockedHelper() {
     // Check that the Callback is destroyed on the same thread as where
     // CallWhileLocked happened if CallWhileLocked happened. If we weren't
     // invoked, thread_checked_ isn't bound to a thread.
     DCHECK(thread_checker_.CalledOnValidThread());
     // Here we read callback_ without the lock. This is why the callback must be
@@ skipping 12 matching lines @@
       // - Because if the callback owns the last ref to a Resource, it will
       //   call the ResourceTracker and also the Resource's destructor, which
       //   both require the ProxyLock.
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
-  scoped_ptr<CallbackType> callback_;
+  std::unique_ptr<CallbackType> callback_;
 
   // Used to ensure that the Callback is run and deleted on the same thread.
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1>
 class RunWhileLockedHelper<void(P1)> {
  public:
   typedef base::Callback<void(P1)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     thread_checker_.DetachFromThread();
   }
-  static void CallWhileLocked(scoped_ptr<RunWhileLockedHelper> ptr, P1 p1) {
+  static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr,
+                              P1 p1) {
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
-      scoped_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
+      std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run(p1);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
-  scoped_ptr<CallbackType> callback_;
+  std::unique_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1, typename P2>
 class RunWhileLockedHelper<void(P1, P2)> {
  public:
   typedef base::Callback<void(P1, P2)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     thread_checker_.DetachFromThread();
   }
-  static void CallWhileLocked(
-      scoped_ptr<RunWhileLockedHelper> ptr, P1 p1, P2 p2) {
+  static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr,
+                              P1 p1,
+                              P2 p2) {
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
-      scoped_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
+      std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run(p1, p2);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
-  scoped_ptr<CallbackType> callback_;
+  std::unique_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1, typename P2, typename P3>
 class RunWhileLockedHelper<void(P1, P2, P3)> {
  public:
   typedef base::Callback<void(P1, P2, P3)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     thread_checker_.DetachFromThread();
   }
-  static void CallWhileLocked(
-      scoped_ptr<RunWhileLockedHelper> ptr, P1 p1, P2 p2, P3 p3) {
+  static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr,
+                              P1 p1,
+                              P2 p2,
+                              P3 p3) {
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
-      scoped_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
+      std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run(p1, p2, p3);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
-  scoped_ptr<CallbackType> callback_;
+  std::unique_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 }  // namespace internal
 
 // RunWhileLocked wraps the given Callback in a new Callback that, when invoked:
 //  1) Locks the ProxyLock.
 //  2) Runs the original Callback (forwarding arguments, if any).
 //  3) Clears the original Callback (while the lock is held).
 //  4) Unlocks the ProxyLock.
@@ skipping 31 matching lines @@
   //   some_task_runner.PostTask(FROM_HERE, RunWhileLocked(local_callback));
   // }
   // In this case, since we don't have a lock synchronizing us, it's possible
   // for the callback to run on the other thread before we return and destroy
   // |local_callback|. The important thing here is that even though the other
   // thread gets a copy of the callback, the internal "BindState" of the
   // callback is refcounted and shared between all copies of the callback. So
   // in that case, if we used base::Owned, we might delete RunWhileLockedHelper
   // on this thread, which will violate the RunWhileLockedHelper's assumption
   // that it is destroyed on the same thread where it is run.
-  scoped_ptr<internal::RunWhileLockedHelper<FunctionType>> helper(
+  std::unique_ptr<internal::RunWhileLockedHelper<FunctionType>> helper(
       new internal::RunWhileLockedHelper<FunctionType>(callback));
   return base::Bind(
       &internal::RunWhileLockedHelper<FunctionType>::CallWhileLocked,
       base::Passed(std::move(helper)));
 }
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PROXY_LOCK_H_