Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/cast_channel/cast_channel_api.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 "extensions/browser/api/cast_channel/cast_channel_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/cast_socket.h"
 #include "extensions/browser/api/cast_channel/keep_alive_delegate.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
@@ skipping 25 matching lines @@
 using cast_channel::Logger;
 using cast_channel::MessageInfo;
 using cast_channel::ReadyState;
 using content::BrowserThread;
 
 namespace {
 
 // T is an extension dictionary (MessageInfo or ChannelInfo)
 template <class T>
 std::string ParamToString(const T& info) {
-  scoped_ptr<base::DictionaryValue> dict = info.ToValue();
+  std::unique_ptr<base::DictionaryValue> dict = info.ToValue();
   std::string out;
   base::JSONWriter::Write(*dict, &out);
   return out;
 }
 
 // Fills |channel_info| from the destination and state of |socket|.
 void FillChannelInfo(const CastSocket& socket, ChannelInfo* channel_info) {
   DCHECK(channel_info);
   channel_info->channel_id = socket.id();
   const net::IPEndPoint& ip_endpoint = socket.ip_endpoint();
@@ skipping 29 matching lines @@
 
 bool IsValidConnectInfoIpAddress(const ConnectInfo& connect_info) {
   net::IPAddress ip_address;
   return ip_address.AssignFromIPLiteral(connect_info.ip_address);
 }
 
 }  // namespace
 
 CastChannelAPI::CastChannelAPI(content::BrowserContext* context)
     : browser_context_(context),
-      logger_(new Logger(make_scoped_ptr<base::Clock>(new base::DefaultClock),
+      logger_(new Logger(base::WrapUnique<base::Clock>(new base::DefaultClock),
                          base::Time::UnixEpoch())) {
   DCHECK(browser_context_);
 }
 
 // static
 CastChannelAPI* CastChannelAPI::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<CastChannelAPI>::Get(context);
 }
 
 scoped_refptr<Logger> CastChannelAPI::GetLogger() {
   return logger_;
 }
 
 void CastChannelAPI::SendEvent(const std::string& extension_id,
-                               scoped_ptr<Event> event) {
+                               std::unique_ptr<Event> event) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   EventRouter* event_router = EventRouter::Get(GetBrowserContext());
   if (event_router) {
     event_router->DispatchEventToExtension(extension_id, std::move(event));
   }
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<CastChannelAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CastChannelAPI>*
 CastChannelAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
-void CastChannelAPI::SetSocketForTest(scoped_ptr<CastSocket> socket_for_test) {
+void CastChannelAPI::SetSocketForTest(
+    std::unique_ptr<CastSocket> socket_for_test) {
   socket_for_test_ = std::move(socket_for_test);
 }
 
-scoped_ptr<CastSocket> CastChannelAPI::GetSocketForTest() {
+std::unique_ptr<CastSocket> CastChannelAPI::GetSocketForTest() {
   return std::move(socket_for_test_);
 }
 
 content::BrowserContext* CastChannelAPI::GetBrowserContext() const {
   return browser_context_;
 }
 
-void CastChannelAPI::SetPingTimeoutTimerForTest(scoped_ptr<base::Timer> timer) {
+void CastChannelAPI::SetPingTimeoutTimerForTest(
+    std::unique_ptr<base::Timer> timer) {
   injected_timeout_timer_ = std::move(timer);
 }
 
-scoped_ptr<base::Timer> CastChannelAPI::GetInjectedTimeoutTimerForTest() {
+std::unique_ptr<base::Timer> CastChannelAPI::GetInjectedTimeoutTimerForTest() {
   return std::move(injected_timeout_timer_);
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
 CastChannelAsyncApiFunction::CastChannelAsyncApiFunction() {
 }
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
@@ skipping 124 matching lines @@
   channel_auth_ = connect_info.auth;
   ip_endpoint_.reset(ParseConnectInfo(connect_info));
   return true;
 }
 
 void CastChannelOpenFunction::AsyncWorkStart() {
   DCHECK(api_);
   DCHECK(ip_endpoint_.get());
   const ConnectInfo& connect_info = params_->connect_info;
   CastSocket* socket;
-  scoped_ptr<CastSocket> test_socket = api_->GetSocketForTest();
+  std::unique_ptr<CastSocket> test_socket = api_->GetSocketForTest();
   if (test_socket.get()) {
     socket = test_socket.release();
   } else {
     socket = new cast_channel::CastSocketImpl(
         extension_->id(), *ip_endpoint_, channel_auth_,
         ExtensionsBrowserClient::Get()->GetNetLog(),
         base::TimeDelta::FromMilliseconds(connect_info.timeout.get()
                                               ? *connect_info.timeout.get()
                                               : kDefaultConnectTimeoutMillis),
         liveness_timeout_ > base::TimeDelta(), api_->GetLogger(),
         connect_info.capabilities.get() ? *connect_info.capabilities.get()
                                         : CastDeviceCapability::NONE);
   }
   new_channel_id_ = AddSocket(socket);
   api_->GetLogger()->LogNewSocketEvent(*socket);
 
   // Construct read delegates.
-  scoped_ptr<api::cast_channel::CastTransport::Delegate> delegate(
-      make_scoped_ptr(new CastMessageHandler(
+  std::unique_ptr<api::cast_channel::CastTransport::Delegate> delegate(
+      base::WrapUnique(new CastMessageHandler(
           base::Bind(&CastChannelAPI::SendEvent, api_->AsWeakPtr()), socket,
           api_->GetLogger())));
   if (socket->keep_alive()) {
     // Wrap read delegate in a KeepAliveDelegate for timeout handling.
     api::cast_channel::KeepAliveDelegate* keep_alive =
         new api::cast_channel::KeepAliveDelegate(
             socket, api_->GetLogger(), std::move(delegate), ping_interval_,
             liveness_timeout_);
-    scoped_ptr<base::Timer> injected_timer =
+    std::unique_ptr<base::Timer> injected_timer =
         api_->GetInjectedTimeoutTimerForTest();
     if (injected_timer) {
       keep_alive->SetTimersForTest(
-          make_scoped_ptr(new base::Timer(false, false)),
+          base::WrapUnique(new base::Timer(false, false)),
           std::move(injected_timer));
     }
     delegate.reset(keep_alive);
   }
 
   api_->GetLogger()->LogNewSocketEvent(*socket);
   socket->Connect(std::move(delegate),
                   base::Bind(&CastChannelOpenFunction::OnOpen, this));
 }
 
@@ skipping 120 matching lines @@
 }
 
 bool CastChannelGetLogsFunction::Prepare() {
   return true;
 }
 
 void CastChannelGetLogsFunction::AsyncWorkStart() {
   DCHECK(api_);
 
   size_t length = 0;
-  scoped_ptr<char[]> out = api_->GetLogger()->GetLogs(&length);
+  std::unique_ptr<char[]> out = api_->GetLogger()->GetLogs(&length);
   if (out.get()) {
     SetResult(new base::BinaryValue(std::move(out), length));
   } else {
     SetError("Unable to get logs.");
   }
 
   api_->GetLogger()->Reset();
 
   AsyncWorkCompleted();
 }
@@ skipping 14 matching lines @@
     cast_channel::ChannelError error_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ChannelInfo channel_info;
   FillChannelInfo(*socket_, &channel_info);
   channel_info.error_state = error_state;
   ErrorInfo error_info;
   FillErrorInfo(error_state, logger_->GetLastErrors(socket_->id()),
                 &error_info);
 
-  scoped_ptr<base::ListValue> results =
+  std::unique_ptr<base::ListValue> results =
       OnError::Create(channel_info, error_info);
-  scoped_ptr<Event> event(new Event(events::CAST_CHANNEL_ON_ERROR,
-                                    OnError::kEventName, std::move(results)));
+  std::unique_ptr<Event> event(new Event(
+      events::CAST_CHANNEL_ON_ERROR, OnError::kEventName, std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, socket_->owner_extension_id(),
                  base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::OnMessage(
     const CastMessage& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   MessageInfo message_info;
   cast_channel::CastMessageToMessageInfo(message, &message_info);
   ChannelInfo channel_info;
   FillChannelInfo(*socket_, &channel_info);
   VLOG(1) << "Received message " << ParamToString(message_info)
           << " on channel " << ParamToString(channel_info);
 
-  scoped_ptr<base::ListValue> results =
+  std::unique_ptr<base::ListValue> results =
       OnMessage::Create(channel_info, message_info);
-  scoped_ptr<Event> event(new Event(events::CAST_CHANNEL_ON_MESSAGE,
-                                    OnMessage::kEventName, std::move(results)));
+  std::unique_ptr<Event> event(new Event(events::CAST_CHANNEL_ON_MESSAGE,
+                                         OnMessage::kEventName,
+                                         std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, socket_->owner_extension_id(),
                  base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::Start() {
 }
 
 CastChannelSetAuthorityKeysFunction::CastChannelSetAuthorityKeysFunction() {
 }
 
 CastChannelSetAuthorityKeysFunction::~CastChannelSetAuthorityKeysFunction() {
 }
 
 bool CastChannelSetAuthorityKeysFunction::Prepare() {
   return true;
 }
 
 void CastChannelSetAuthorityKeysFunction::AsyncWorkStart() {
   // TODO(eroman): crbug.com/601171: Delete this once the API is
   // removed. It is currently a no-op.
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions