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

extensions/browser/api/cast_channel/logger.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/logger.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <utility>
@@ skipping 46 matching lines @@
     case AuthResult::ERROR_CANNOT_EXTRACT_PUBLIC_KEY:
       return proto::CHALLENGE_REPLY_ERROR_CANNOT_EXTRACT_PUBLIC_KEY;
     case AuthResult::ERROR_SIGNED_BLOBS_MISMATCH:
       return proto::CHALLENGE_REPLY_ERROR_SIGNED_BLOBS_MISMATCH;
     default:
       NOTREACHED();
       return proto::CHALLENGE_REPLY_ERROR_NONE;
   }
 }
 
-scoped_ptr<char[]> Compress(const std::string& input, size_t* length) {
+std::unique_ptr<char[]> Compress(const std::string& input, size_t* length) {
   *length = 0;
   z_stream stream = {0};
   int result = deflateInit2(&stream,
                             Z_DEFAULT_COMPRESSION,
                             Z_DEFLATED,
                             // 16 is added to produce a gzip header + trailer.
                             MAX_WBITS + 16,
                             8,  // memLevel = 8 is default.
                             Z_DEFAULT_STRATEGY);
   DCHECK_EQ(Z_OK, result);
 
   size_t out_size = deflateBound(&stream, input.size());
-  scoped_ptr<char[]> out(new char[out_size]);
+  std::unique_ptr<char[]> out(new char[out_size]);
 
   stream.next_in = reinterpret_cast<uint8_t*>(const_cast<char*>(input.data()));
   stream.avail_in = input.size();
   stream.next_out = reinterpret_cast<uint8_t*>(out.get());
   stream.avail_out = out_size;
 
   // Do a one-shot compression. This will return Z_STREAM_END only if |output|
   // is large enough to hold all compressed data.
   result = deflate(&stream, Z_FINISH);
 
@@ skipping 27 matching lines @@
 }
 
 }  // namespace
 
 Logger::AggregatedSocketEventLog::AggregatedSocketEventLog() {
 }
 
 Logger::AggregatedSocketEventLog::~AggregatedSocketEventLog() {
 }
 
-Logger::Logger(scoped_ptr<base::Clock> clock, base::Time unix_epoch_time)
+Logger::Logger(std::unique_ptr<base::Clock> clock, base::Time unix_epoch_time)
     : clock_(std::move(clock)), unix_epoch_time_(unix_epoch_time) {
   DCHECK(clock_);
 
   // Logger may not be necessarily be created on the IO thread, but logging
   // happens exclusively there.
   thread_checker_.DetachFromThread();
 }
 
 Logger::~Logger() {
 }
@@ skipping 165 matching lines @@
     socket_events.pop_front();
     log_.set_num_evicted_socket_events(log_.num_evicted_socket_events() + 1);
   }
   socket_events.push_back(socket_event);
 
   MaybeSetLastErrors(socket_event, &(it->second->last_errors));
 
   return it->second->aggregated_socket_event;
 }
 
-scoped_ptr<char[]> Logger::GetLogs(size_t* length) const {
+std::unique_ptr<char[]> Logger::GetLogs(size_t* length) const {
   *length = 0;
 
   Log log;
   // Copy "global" values from |log_|. Don't use |log_| directly since this
   // function is const.
   log.CopyFrom(log_);
 
   for (AggregatedSocketEventLogMap::const_iterator it =
            aggregated_socket_events_.begin();
        it != aggregated_socket_events_.end();
        ++it) {
     AggregatedSocketEvent* new_aggregated_socket_event =
         log.add_aggregated_socket_event();
     new_aggregated_socket_event->CopyFrom(it->second->aggregated_socket_event);
 
     const std::deque<SocketEvent>& socket_events = it->second->socket_events;
     for (std::deque<SocketEvent>::const_iterator socket_event_it =
              socket_events.begin();
          socket_event_it != socket_events.end();
          ++socket_event_it) {
       SocketEvent* socket_event =
           new_aggregated_socket_event->add_socket_event();
       socket_event->CopyFrom(*socket_event_it);
     }
   }
 
   std::string serialized;
   if (!log.SerializeToString(&serialized)) {
     VLOG(2) << "Failed to serialized proto to string.";
-    return scoped_ptr<char[]>();
+    return std::unique_ptr<char[]>();
   }
 
   return Compress(serialized, length);
 }
 
 void Logger::Reset() {
   aggregated_socket_events_.clear();
   log_.Clear();
 }
 
 LastErrors Logger::GetLastErrors(int channel_id) const {
   AggregatedSocketEventLogMap::const_iterator it =
       aggregated_socket_events_.find(channel_id);
   if (it != aggregated_socket_events_.end()) {
     return it->second->last_errors;
   } else {
     return LastErrors();
   }
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions