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

extensions/browser/api/cast_channel/cast_framer.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_framer.h"
 
 #include <stdlib.h>
 
 #include <limits>
 
@@ skipping 22 matching lines @@
   DCHECK_GT(size, 0U);
   message_size = size;
 }
 
 // TODO(mfoltz): Investigate replacing header serialization with base::Pickle,
 // if bit-for-bit compatible.
 void MessageFramer::MessageHeader::PrependToString(std::string* str) {
   MessageHeader output = *this;
   output.message_size = base::HostToNet32(message_size);
   size_t header_size = MessageHeader::header_size();
-  scoped_ptr<char, base::FreeDeleter> char_array(
+  std::unique_ptr<char, base::FreeDeleter> char_array(
       static_cast<char*>(malloc(header_size)));
   memcpy(char_array.get(), &output, header_size);
   str->insert(0, char_array.get(), header_size);
 }
 
 // TODO(mfoltz): Investigate replacing header deserialization with base::Pickle,
 // if bit-for-bit compatible.
 void MessageFramer::MessageHeader::Deserialize(char* data,
                                                MessageHeader* header) {
   uint32_t message_size;
@@ skipping 52 matching lines @@
           bytes_left,
           MessageHeader::max_message_size() - MessageHeader::header_size());
       VLOG(2) << "Bytes needed for body: " << bytes_left;
       return bytes_left;
     default:
       NOTREACHED() << "Unhandled packet element type.";
       return 0;
   }
 }
 
-scoped_ptr<CastMessage> MessageFramer::Ingest(size_t num_bytes,
-                                              size_t* message_length,
-                                              ChannelError* error) {
+std::unique_ptr<CastMessage> MessageFramer::Ingest(size_t num_bytes,
+                                                   size_t* message_length,
+                                                   ChannelError* error) {
   DCHECK(error);
   DCHECK(message_length);
   if (error_) {
     *error = CHANNEL_ERROR_INVALID_MESSAGE;
     return nullptr;
   }
 
   DCHECK_EQ(base::checked_cast<int32_t>(message_bytes_received_),
             input_buffer_->offset());
   CHECK_LE(num_bytes, BytesRequested());
@@ skipping 11 matching lines @@
           *error = CHANNEL_ERROR_INVALID_MESSAGE;
           error_ = true;
           return nullptr;
         }
         current_element_ = BODY;
         body_size_ = header.message_size;
       }
       break;
     case BODY:
       if (BytesRequested() == 0) {
-        scoped_ptr<CastMessage> parsed_message(new CastMessage);
+        std::unique_ptr<CastMessage> parsed_message(new CastMessage);
         if (!parsed_message->ParseFromArray(
                 input_buffer_->StartOfBuffer() + MessageHeader::header_size(),
                 body_size_)) {
           VLOG(1) << "Error parsing packet body.";
           *error = CHANNEL_ERROR_INVALID_MESSAGE;
           error_ = true;
           return nullptr;
         }
         *message_length = body_size_;
         Reset();
@@ skipping 12 matching lines @@
 void MessageFramer::Reset() {
   current_element_ = HEADER;
   message_bytes_received_ = 0;
   body_size_ = 0;
   input_buffer_->set_offset(0);
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions