Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/pepper/pepper_broker.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 "content/renderer/pepper/pepper_broker.h"
 
 #include "build/build_config.h"
 #include "content/renderer/pepper/pepper_proxy_channel_delegate_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/ppb_broker_impl.h"
@@ skipping 130 matching lines @@
   // TODO(ddorwin): Send message disconnect message using dispatcher_.
 
   // Release the reference added in Connect().
   // This must be the last statement because it may delete this object.
   Release();
 }
 
 void PepperBroker::OnBrokerChannelConnected(
     base::ProcessId broker_pid,
     const IPC::ChannelHandle& channel_handle) {
-  scoped_ptr<PepperBrokerDispatcherWrapper> dispatcher(
+  std::unique_ptr<PepperBrokerDispatcherWrapper> dispatcher(
       new PepperBrokerDispatcherWrapper);
   if (!dispatcher->Init(broker_pid, channel_handle)) {
     ReportFailureToClients(PP_ERROR_FAILED);
     return;
   }
 
   dispatcher_.reset(dispatcher.release());
 
   // Process all pending channel requests from the plugins.
   for (ClientMap::iterator i = pending_connects_.begin();
@@ skipping 65 matching lines @@
   }
   pending_connects_.clear();
 }
 
 void PepperBroker::ConnectPluginToBroker(PPB_Broker_Impl* client) {
   base::SyncSocket::Handle plugin_handle = base::SyncSocket::kInvalidHandle;
   int32_t result = PP_OK;
 
   // The socket objects will be deleted when this function exits, closing the
   // handles. Any uses of the socket must duplicate them.
-  scoped_ptr<base::SyncSocket> broker_socket(new base::SyncSocket());
-  scoped_ptr<base::SyncSocket> plugin_socket(new base::SyncSocket());
+  std::unique_ptr<base::SyncSocket> broker_socket(new base::SyncSocket());
+  std::unique_ptr<base::SyncSocket> plugin_socket(new base::SyncSocket());
   if (base::SyncSocket::CreatePair(broker_socket.get(), plugin_socket.get())) {
     result = dispatcher_->SendHandleToBroker(client->pp_instance(),
                                              broker_socket->handle());
 
     // If the broker has its pipe handle, duplicate the plugin's handle.
     // Otherwise, the plugin's handle will be automatically closed.
     if (result == PP_OK)
       plugin_handle = DuplicateHandle(plugin_socket->handle());
   } else {
     result = PP_ERROR_FAILED;
   }
 
   // TOOD(ddorwin): Change the IPC to asynchronous: Queue an object containing
   // client and plugin_socket.release(), then return.
   // That message handler will then call client->BrokerConnected() with the
   // saved pipe handle.
   // Temporarily, just call back.
   client->BrokerConnected(ppapi::PlatformFileToInt(plugin_handle), result);
 }
 
 }  // namespace content