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

extensions/browser/api/cast_channel/keep_alive_delegate.cc

 // Copyright 2015 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/keep_alive_delegate.h"
 
 #include <string>
 #include <utility>
 
 #include "base/json/json_reader.h"
@@ skipping 18 matching lines @@
 // Determines if the JSON-encoded payload is equivalent to
 // { "type": |chk_type| }
 bool NestedPayloadTypeEquals(const std::string& chk_type,
                              const CastMessage& message) {
   MessageInfo message_info;
   CastMessageToMessageInfo(message, &message_info);
   std::string type_json;
   if (!message_info.data->GetAsString(&type_json)) {
     return false;
   }
-  scoped_ptr<base::Value> type_value(base::JSONReader::Read(type_json));
+  std::unique_ptr<base::Value> type_value(base::JSONReader::Read(type_json));
   if (!type_value.get()) {
     return false;
   }
 
   base::DictionaryValue* type_dict;
   if (!type_value->GetAsDictionary(&type_dict)) {
     return false;
   }
 
   std::string type_string;
@@ skipping 25 matching lines @@
     return output;
   }
   output.set_payload_type(
       CastMessage::PayloadType::CastMessage_PayloadType_STRING);
   return output;
 }
 
 KeepAliveDelegate::KeepAliveDelegate(
     CastSocket* socket,
     scoped_refptr<Logger> logger,
-    scoped_ptr<CastTransport::Delegate> inner_delegate,
+    std::unique_ptr<CastTransport::Delegate> inner_delegate,
     base::TimeDelta ping_interval,
     base::TimeDelta liveness_timeout)
     : started_(false),
       socket_(socket),
       logger_(logger),
       inner_delegate_(std::move(inner_delegate)),
       liveness_timeout_(liveness_timeout),
       ping_interval_(ping_interval) {
   DCHECK(ping_interval_ < liveness_timeout_);
   DCHECK(inner_delegate_);
   DCHECK(socket_);
   ping_message_ = CreateKeepAliveMessage(kHeartbeatPingType);
   pong_message_ = CreateKeepAliveMessage(kHeartbeatPongType);
 }
 
 KeepAliveDelegate::~KeepAliveDelegate() {
 }
 
 void KeepAliveDelegate::SetTimersForTest(
-    scoped_ptr<base::Timer> injected_ping_timer,
-    scoped_ptr<base::Timer> injected_liveness_timer) {
+    std::unique_ptr<base::Timer> injected_ping_timer,
+    std::unique_ptr<base::Timer> injected_liveness_timer) {
   ping_timer_ = std::move(injected_ping_timer);
   liveness_timer_ = std::move(injected_liveness_timer);
 }
 
 void KeepAliveDelegate::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!started_);
 
   VLOG(1) << "Starting keep-alive timers.";
   VLOG(1) << "Ping timeout: " << ping_interval_;
@@ skipping 80 matching lines @@
   if (started_) {
     started_ = false;
     ping_timer_->Stop();
     liveness_timer_->Stop();
   }
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions