Convert //chrome from scoped_ptr to std::unique_ptr

chrome/utility/safe_browsing/mac/udif.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 "chrome/utility/safe_browsing/mac/udif.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <bzlib.h>
 #include <libkern/OSByteOrder.h>
 #include <uuid/uuid.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/utility/safe_browsing/mac/convert_big_endian.h"
 #include "chrome/utility/safe_browsing/mac/read_stream.h"
 #include "third_party/zlib/zlib.h"
 
 namespace safe_browsing {
 namespace dmg {
 
 #pragma pack(push, 1)
@@ skipping 198 matching lines @@
   bool Read(uint8_t* buffer, size_t buffer_size, size_t* bytes_read) override;
   // Seek only supports SEEK_SET and SEEK_CUR.
   off_t Seek(off_t offset, int whence) override;
 
  private:
   ReadStream* const stream_;  // The UDIF stream.
   const uint16_t block_size_;  // The UDIF block size.
   const UDIFBlock* const block_;  // The block for this partition.
   uint64_t current_chunk_;  // The current chunk number.
   // The current chunk stream.
-  scoped_ptr<UDIFBlockChunkReadStream> chunk_stream_;
+  std::unique_ptr<UDIFBlockChunkReadStream> chunk_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(UDIFPartitionReadStream);
 };
 
 // A ReadStream for a single block chunk, which transparently handles
 // decompression.
 class UDIFBlockChunkReadStream : public ReadStream {
  public:
   UDIFBlockChunkReadStream(ReadStream* stream,
                            uint16_t block_size,
@@ skipping 83 matching lines @@
 }
 
 size_t UDIFParser::GetPartitionSize(size_t part_number) {
   DCHECK_LT(part_number, blocks_.size());
   auto size =
       base::CheckedNumeric<size_t>(blocks_[part_number]->sector_count()) *
       block_size_;
   return size.ValueOrDie();
 }
 
-scoped_ptr<ReadStream> UDIFParser::GetPartitionReadStream(size_t part_number) {
+std::unique_ptr<ReadStream> UDIFParser::GetPartitionReadStream(
+    size_t part_number) {
   DCHECK_LT(part_number, blocks_.size());
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new UDIFPartitionReadStream(stream_, block_size_, blocks_[part_number]));
 }
 
 bool UDIFParser::ParseBlkx() {
   UDIFResourceFile trailer;
   if (stream_->Seek(-sizeof(trailer), SEEK_END) == -1)
     return false;
 
   if (!stream_->ReadType(&trailer)) {
     DLOG(ERROR) << "Failed to read UDIFResourceFile";
@@ skipping 73 matching lines @@
                                                              CFSTR("Data"));
     if (!data) {
       DLOG(ERROR) << "Skipping block " << i
                   << " because it has no Data section";
       continue;
     }
 
     // Copy the block table out of the plist.
     auto block_data =
         reinterpret_cast<const UDIFBlockData*>(CFDataGetBytePtr(data));
-    scoped_ptr<UDIFBlock> block(new UDIFBlock(block_data));
+    std::unique_ptr<UDIFBlock> block(new UDIFBlock(block_data));
 
     if (block->signature() != UDIFBlockData::kSignature) {
       DLOG(ERROR) << "Skipping block " << i << " because its signature does not"
                   << " match, is 0x" << std::hex << block->signature();
       continue;
     }
     if (block->version() != UDIFBlockData::kVersion) {
       DLOG(ERROR) << "Skipping block " << i << "because its version does not "
                   << "match, is " << block->version();
       continue;
@@ skipping 339 matching lines @@
                 << chunk_->compressed_offset;
     return false;
   }
   return true;
 }
 
 }  // namespace
 
 }  // namespace dmg
 }  // namespace safe_browsing