Convert //ppapi to use std::unique_ptr

ppapi/proxy/message_handler.cc

 // Copyright 2014 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/proxy/message_handler.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 18 matching lines @@
                           void* user_data,
                           ScopedPPVar message_data) {
   CallWhileUnlocked(function, instance, user_data,
                     &message_data.get());
 }
 
 void HandleBlockingMessageWrapper(HandleBlockingMessageFunc function,
                                   PP_Instance instance,
                                   void* user_data,
                                   ScopedPPVar message_data,
-                                  scoped_ptr<IPC::Message> reply_msg) {
+                                  std::unique_ptr<IPC::Message> reply_msg) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   PP_Var result = PP_MakeUndefined();
   MessageLoopResource::GetCurrent()->
       set_currently_handling_blocking_message(true);
   CallWhileUnlocked(
       function, instance, user_data, &message_data.get(), &result);
   MessageLoopResource::GetCurrent()->
       set_currently_handling_blocking_message(false);
   PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
       reply_msg.get(),
       SerializedVarReturnValue::Convert(dispatcher, result),
       true /* was_handled */);
   dispatcher->Send(reply_msg.release());
 }
 
 }  // namespace
 
 // static
-scoped_ptr<MessageHandler> MessageHandler::Create(
-      PP_Instance instance,
-      const PPP_MessageHandler_0_2* handler_if,
-      void* user_data,
-      PP_Resource message_loop,
-      int32_t* error) {
-  scoped_ptr<MessageHandler> result;
+std::unique_ptr<MessageHandler> MessageHandler::Create(
+    PP_Instance instance,
+    const PPP_MessageHandler_0_2* handler_if,
+    void* user_data,
+    PP_Resource message_loop,
+    int32_t* error) {
+  std::unique_ptr<MessageHandler> result;
   // The interface and all function pointers must be valid.
   if (!handler_if ||
       !handler_if->HandleMessage ||
       !handler_if->HandleBlockingMessage ||
       !handler_if->Destroy) {
     *error = PP_ERROR_BADARGUMENT;
     return result;
   }
   thunk::EnterResourceNoLock<thunk::PPB_MessageLoop_API>
       enter_loop(message_loop, true);
@@ skipping 29 matching lines @@
   return !!message_loop_->task_runner().get();
 }
 
 void MessageHandler::HandleMessage(ScopedPPVar var) {
   message_loop_->task_runner()->PostTask(
       FROM_HERE, RunWhileLocked(base::Bind(&HandleMessageWrapper,
                                            handler_if_->HandleMessage,
                                            instance_, user_data_, var)));
 }
 
-void MessageHandler::HandleBlockingMessage(ScopedPPVar var,
-                                           scoped_ptr<IPC::Message> reply_msg) {
+void MessageHandler::HandleBlockingMessage(
+    ScopedPPVar var,
+    std::unique_ptr<IPC::Message> reply_msg) {
   message_loop_->task_runner()->PostTask(
       FROM_HERE,
       RunWhileLocked(base::Bind(
           &HandleBlockingMessageWrapper, handler_if_->HandleBlockingMessage,
           instance_, user_data_, var, base::Passed(std::move(reply_msg)))));
 }
 
 MessageHandler::MessageHandler(
     PP_Instance instance,
     const PPP_MessageHandler_0_2* handler_if,
     void* user_data,
     scoped_refptr<MessageLoopResource> message_loop)
     : instance_(instance),
       handler_if_(handler_if),
       user_data_(user_data),
       message_loop_(message_loop) {
 }
 
 }  // namespace proxy
 }  // namespace ppapi