Convert //ppapi to use std::unique_ptr

ppapi/proxy/ppapi_proxy_test.h

Index: ppapi/proxy/ppapi_proxy_test.h
diff --git a/ppapi/proxy/ppapi_proxy_test.h b/ppapi/proxy/ppapi_proxy_test.h
index ec9907175fc28f244f61ff8635e35df8e0c645be..670753ede63eed31d39760363a2c981573f6a894 100644
--- a/ppapi/proxy/ppapi_proxy_test.h
+++ b/ppapi/proxy/ppapi_proxy_test.h
@@ -5,12 +5,12 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner.h"
 #include "base/threading/simple_thread.h"
@@ -177,9 +177,9 @@ class PluginProxyTestHarness : public ProxyTestHarnessBase {
       const scoped_refptr<base::TaskRunner>& ipc_task_runner);
 
   GlobalsConfiguration globals_config_;
-  scoped_ptr<PluginGlobals> plugin_globals_;
+  std::unique_ptr<PluginGlobals> plugin_globals_;
 
-  scoped_ptr<PluginDispatcher> plugin_dispatcher_;
+  std::unique_ptr<PluginDispatcher> plugin_dispatcher_;
   PluginDelegateMock plugin_delegate_mock_;
 };
 
@@ -240,8 +240,8 @@ class PluginProxyMultiThreadTest
   static void InternalSetUpTestOnSecondaryThread(void* user_data,
                                                  int32_t result);
 
-  scoped_ptr<base::DelegateSimpleThread> secondary_thread_;
-  scoped_ptr<base::RunLoop> nested_main_thread_message_loop_;
+  std::unique_ptr<base::DelegateSimpleThread> secondary_thread_;
+  std::unique_ptr<base::RunLoop> nested_main_thread_message_loop_;
 };
 
 class HostProxyTestHarness : public ProxyTestHarnessBase {
@@ -301,11 +301,11 @@ class HostProxyTestHarness : public ProxyTestHarnessBase {
   void CreateHostGlobals();
 
   GlobalsConfiguration globals_config_;
-  scoped_ptr<ppapi::TestGlobals> host_globals_;
-  scoped_ptr<HostDispatcher> host_dispatcher_;
+  std::unique_ptr<ppapi::TestGlobals> host_globals_;
+  std::unique_ptr<HostDispatcher> host_dispatcher_;
   // The host side of the real proxy doesn't lock, so this disables locking for
   // the thread the host side of the test runs on.
-  scoped_ptr<ProxyLock::LockingDisablerForTest> disable_locking_;
+  std::unique_ptr<ProxyLock::LockingDisablerForTest> disable_locking_;
   DelegateMock delegate_mock_;
 };