Convert //ppapi to use std::unique_ptr

ppapi/shared_impl/thread_aware_callback_unittest.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 "ppapi/shared_impl/thread_aware_callback.h"
 
+#include <memory>
+
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ppapi {
 
 namespace {
 
 class TestParameter {
@@ skipping 64 matching lines @@
 
     {
       ProxyAutoLock auto_lock;
       // We have to destroy it prior to the PluginGlobals instance held by the
       // base class. Otherwise it has a ref to Pepper message loop for the main
       // thread and the PluginGlobals destructor will complain.
       thiz->main_thread_callback_.reset(NULL);
     }
   }
 
-  scoped_ptr<ThreadAwareCallback<CallbackFunc> > main_thread_callback_;
+  std::unique_ptr<ThreadAwareCallback<CallbackFunc>> main_thread_callback_;
   bool main_thread_callback_called_;
 };
 
 // Test that when a ThreadAwareCallback instance is destroyed, pending tasks to
 // run the callback will be ignored.
 class ThreadAwareCallbackAbortTest : public proxy::PluginProxyMultiThreadTest {
  public:
   ThreadAwareCallbackAbortTest() {}
   ~ThreadAwareCallbackAbortTest() override {}
 
@@ skipping 28 matching lines @@
   static void MainThreadCallbackBody(ThreadAwareCallbackAbortTest* thiz) {
     // The callback should not be called.
     ASSERT_TRUE(false);
   }
 
   void DeleteCallback() {
     ProxyAutoLock auto_lock;
     main_thread_callback_.reset(NULL);
   }
 
-  scoped_ptr<ThreadAwareCallback<CallbackFunc> > main_thread_callback_;
+  std::unique_ptr<ThreadAwareCallback<CallbackFunc>> main_thread_callback_;
 };
 
 }  // namespace
 
 TEST_F(ThreadAwareCallbackTest, Basics) {
   // ThreadAwareCallback should only be used when the proxy lock has been
   // acquired.
   ProxyAutoLock auto_lock;
 
   double double_arg = 0.0;
   bool bool_arg = false;
   TestParameter object_arg;
 
   // Exercise all the template code.
   called_num = 0;
   typedef void (*FuncType_0)();
-  scoped_ptr<ThreadAwareCallback<FuncType_0> > callback_0(
+  std::unique_ptr<ThreadAwareCallback<FuncType_0>> callback_0(
       ThreadAwareCallback<FuncType_0>::Create(TestCallback_0));
   callback_0->RunOnTargetThread();
 
   typedef void (*FuncType_1)(int);
-  scoped_ptr<ThreadAwareCallback<FuncType_1> > callback_1(
+  std::unique_ptr<ThreadAwareCallback<FuncType_1>> callback_1(
       ThreadAwareCallback<FuncType_1>::Create(TestCallback_1));
   callback_1->RunOnTargetThread(1);
 
   typedef void (*FuncType_2)(int, const double*);
-  scoped_ptr<ThreadAwareCallback<FuncType_2> > callback_2(
+  std::unique_ptr<ThreadAwareCallback<FuncType_2>> callback_2(
       ThreadAwareCallback<FuncType_2>::Create(TestCallback_2));
   callback_2->RunOnTargetThread(1, &double_arg);
 
   typedef void (*FuncType_3)(int, const double*, bool*);
-  scoped_ptr<ThreadAwareCallback<FuncType_3> > callback_3(
+  std::unique_ptr<ThreadAwareCallback<FuncType_3>> callback_3(
       ThreadAwareCallback<FuncType_3>::Create(TestCallback_3));
   callback_3->RunOnTargetThread(1, &double_arg, &bool_arg);
 
   typedef void (*FuncType_4)(int, const double*, bool*, TestParameter);
-  scoped_ptr<ThreadAwareCallback<FuncType_4> > callback_4(
+  std::unique_ptr<ThreadAwareCallback<FuncType_4>> callback_4(
       ThreadAwareCallback<FuncType_4>::Create(TestCallback_4));
   callback_4->RunOnTargetThread(1, &double_arg, &bool_arg, object_arg);
 
   typedef void (*FuncType_5)(
       int, const double*, bool*, TestParameter, const TestParameter&);
-  scoped_ptr<ThreadAwareCallback<FuncType_5> > callback_5(
+  std::unique_ptr<ThreadAwareCallback<FuncType_5>> callback_5(
       ThreadAwareCallback<FuncType_5>::Create(TestCallback_5));
   callback_5->RunOnTargetThread(
       1, &double_arg, &bool_arg, object_arg, object_arg);
 
   EXPECT_EQ(6, called_num);
 }
 
 TEST_F(ThreadAwareCallbackMultiThreadTest, RunOnTargetThread) { RunTest(); }
 
 TEST_F(ThreadAwareCallbackAbortTest, NotRunIfAborted) { RunTest(); }
 
 }  // namespace ppapi