Convert media/formats to std::unique_ptr

media/formats/webm/cluster_builder.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 "media/formats/webm/cluster_builder.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "media/base/data_buffer.h"
 #include "media/formats/webm/webm_constants.h"
 
 namespace media {
 
 static const uint8_t kClusterHeader[] = {
     0x1F, 0x43, 0xB6, 0x75,                          // CLUSTER ID
@@ skipping 32 matching lines @@
   kSimpleBlockSizeOffset = 1,
 
   kBlockGroupSizeOffset = 1,
   kBlockGroupWithoutBlockDurationBlockSizeOffset = 10,
   kBlockGroupDurationOffset = 11,
   kBlockGroupBlockSizeOffset = 20,
 
   kInitialBufferSize = 32768,
 };
 
-Cluster::Cluster(scoped_ptr<uint8_t[]> data, int size)
+Cluster::Cluster(std::unique_ptr<uint8_t[]> data, int size)
     : data_(std::move(data)), size_(size) {}
 Cluster::~Cluster() {}
 
 ClusterBuilder::ClusterBuilder() { Reset(); }
 ClusterBuilder::~ClusterBuilder() {}
 
 void ClusterBuilder::SetClusterTimecode(int64_t cluster_timecode) {
   DCHECK_EQ(cluster_timecode_, -1);
 
   cluster_timecode_ = cluster_timecode;
@@ skipping 109 matching lines @@
   DCHECK_GE(timecode_delta, -32768);
   DCHECK_LE(timecode_delta, 32767);
 
   buf[0] = 0x80 | (track_num & 0x7F);
   buf[1] = (timecode_delta >> 8) & 0xff;
   buf[2] = timecode_delta & 0xff;
   buf[3] = flags & 0xff;
   memcpy(buf + 4, data, size);
 }
 
-scoped_ptr<Cluster> ClusterBuilder::Finish() {
+std::unique_ptr<Cluster> ClusterBuilder::Finish() {
   DCHECK_NE(cluster_timecode_, -1);
 
   UpdateUInt64(kClusterSizeOffset, bytes_used_ - (kClusterSizeOffset + 8));
 
-  scoped_ptr<Cluster> ret(new Cluster(std::move(buffer_), bytes_used_));
+  std::unique_ptr<Cluster> ret(new Cluster(std::move(buffer_), bytes_used_));
   Reset();
   return ret;
 }
 
-scoped_ptr<Cluster> ClusterBuilder::FinishWithUnknownSize() {
+std::unique_ptr<Cluster> ClusterBuilder::FinishWithUnknownSize() {
   DCHECK_NE(cluster_timecode_, -1);
 
   UpdateUInt64(kClusterSizeOffset, kWebMUnknownSize);
 
-  scoped_ptr<Cluster> ret(new Cluster(std::move(buffer_), bytes_used_));
+  std::unique_ptr<Cluster> ret(new Cluster(std::move(buffer_), bytes_used_));
   Reset();
   return ret;
 }
 
 void ClusterBuilder::Reset() {
   buffer_size_ = kInitialBufferSize;
   buffer_.reset(new uint8_t[buffer_size_]);
   memcpy(buffer_.get(), kClusterHeader, sizeof(kClusterHeader));
   bytes_used_ = sizeof(kClusterHeader);
   cluster_timecode_ = -1;
 }
 
 void ClusterBuilder::ExtendBuffer(int bytes_needed) {
   int new_buffer_size = 2 * buffer_size_;
 
   while ((new_buffer_size - bytes_used_) < bytes_needed)
     new_buffer_size *= 2;
 
-  scoped_ptr<uint8_t[]> new_buffer(new uint8_t[new_buffer_size]);
+  std::unique_ptr<uint8_t[]> new_buffer(new uint8_t[new_buffer_size]);
 
   memcpy(new_buffer.get(), buffer_.get(), bytes_used_);
   buffer_.reset(new_buffer.release());
   buffer_size_ = new_buffer_size;
 }
 
 void ClusterBuilder::UpdateUInt64(int offset, int64_t value) {
   DCHECK_LE(offset + 7, buffer_size_);
   uint8_t* buf = buffer_.get() + offset;
 
   // Fill the last 7 bytes of size field in big-endian order.
   for (int i = 7; i > 0; i--) {
     buf[i] = value & 0xff;
     value >>= 8;
   }
 }
 
 }  // namespace media