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

chrome/browser/extensions/api/image_writer_private/test_utils.cc

 // Copyright 2013 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/browser/extensions/api/image_writer_private/test_utils.h"
 
 #include <string.h>
 #include <utility>
 
 #include "build/build_config.h"
@@ skipping 147 matching lines @@
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &test_image_path_));
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &test_device_path_));
 
   ASSERT_TRUE(FillFile(test_image_path_, kImagePattern, kTestFileSize));
   ASSERT_TRUE(FillFile(test_device_path_, kDevicePattern, kTestFileSize));
 
 #if defined(OS_CHROMEOS)
   if (!chromeos::DBusThreadManager::IsInitialized()) {
-    scoped_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
+    std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
         chromeos::DBusThreadManager::GetSetterForTesting();
-    scoped_ptr<chromeos::ImageBurnerClient>
-        image_burner_fake(new ImageWriterFakeImageBurnerClient());
+    std::unique_ptr<chromeos::ImageBurnerClient> image_burner_fake(
+        new ImageWriterFakeImageBurnerClient());
     dbus_setter->SetImageBurnerClient(std::move(image_burner_fake));
   }
 
   FakeDiskMountManager* disk_manager = new FakeDiskMountManager();
   chromeos::disks::DiskMountManager::InitializeForTesting(disk_manager);
 
   // Adds a disk entry for test_device_path_ with the same device and file path.
   disk_manager->CreateDiskEntryForMountDevice(
       chromeos::disks::DiskMountManager::MountPointInfo(
           test_device_path_.value(),
@@ skipping 41 matching lines @@
   return test_device_path_;
 }
 
 #if !defined(OS_CHROMEOS)
 FakeImageWriterClient* ImageWriterTestUtils::GetUtilityClient() {
   return client_.get();
 }
 #endif
 
 bool ImageWriterTestUtils::ImageWrittenToDevice() {
-  scoped_ptr<char[]> image_buffer(new char[kTestFileSize]);
-  scoped_ptr<char[]> device_buffer(new char[kTestFileSize]);
+  std::unique_ptr<char[]> image_buffer(new char[kTestFileSize]);
+  std::unique_ptr<char[]> device_buffer(new char[kTestFileSize]);
 
   int image_bytes_read =
       ReadFile(test_image_path_, image_buffer.get(), kTestFileSize);
 
   if (image_bytes_read < 0)
     return false;
 
   int device_bytes_read =
       ReadFile(test_device_path_, device_buffer.get(), kTestFileSize);
 
   if (image_bytes_read != device_bytes_read)
     return false;
 
   return memcmp(image_buffer.get(), device_buffer.get(), image_bytes_read) == 0;
 }
 
 bool ImageWriterTestUtils::FillFile(const base::FilePath& file,
                                     const int pattern,
                                     const int length) {
-  scoped_ptr<char[]> buffer(new char[length]);
+  std::unique_ptr<char[]> buffer(new char[length]);
   memset(buffer.get(), pattern, length);
 
   return base::WriteFile(file, buffer.get(), length) == length;
 }
 
 ImageWriterUnitTestBase::ImageWriterUnitTestBase()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 }
 ImageWriterUnitTestBase::~ImageWriterUnitTestBase() {
 }
 
 void ImageWriterUnitTestBase::SetUp() {
   testing::Test::SetUp();
   test_utils_.SetUp();
 }
 
 void ImageWriterUnitTestBase::TearDown() {
   testing::Test::TearDown();
   test_utils_.TearDown();
 }
 
 }  // namespace image_writer
 }  // namespace extensions