Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/quota/quota_reservation_manager_unittest.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 <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "storage/browser/fileapi/quota/open_file_handle.h"
 #include "storage/browser/fileapi/quota/quota_reservation.h"
 #include "storage/browser/fileapi/quota/quota_reservation_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::kFileSystemTypeTemporary;
 using storage::OpenFileHandle;
@@ skipping 69 matching lines @@
 
  private:
   int64_t on_memory_usage_;
   int64_t on_disk_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeBackend);
 };
 
 class FakeWriter {
  public:
-  explicit FakeWriter(scoped_ptr<OpenFileHandle> handle)
+  explicit FakeWriter(std::unique_ptr<OpenFileHandle> handle)
       : handle_(std::move(handle)),
         path_(handle_->platform_path()),
         max_written_offset_(handle_->GetEstimatedFileSize()),
         append_mode_write_amount_(0),
         dirty_(false) {}
 
   ~FakeWriter() {
     if (handle_)
       EXPECT_FALSE(dirty_);
   }
@@ skipping 35 matching lines @@
     max_written_offset_ = handle_->GetEstimatedFileSize();
     append_mode_write_amount_ = 0;
     dirty_ = false;
   }
 
   void ClearWithoutUsageReport() {
     handle_.reset();
   }
 
  private:
-  scoped_ptr<OpenFileHandle> handle_;
+  std::unique_ptr<OpenFileHandle> handle_;
   base::FilePath path_;
   int64_t max_written_offset_;
   int64_t append_mode_write_amount_;
   bool dirty_;
 };
 
 void ExpectSuccess(bool* done, base::File::Error error) {
   EXPECT_FALSE(*done);
   *done = true;
   EXPECT_EQ(base::File::FILE_OK, error);
@@ skipping 13 matching lines @@
 class QuotaReservationManagerTest : public testing::Test {
  public:
   QuotaReservationManagerTest() {}
   ~QuotaReservationManagerTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(work_dir_.CreateUniqueTempDir());
     file_path_ = work_dir_.path().Append(FILE_PATH_LITERAL("hoge"));
     SetFileSize(file_path_, kInitialFileSize);
 
-    scoped_ptr<QuotaReservationManager::QuotaBackend> backend(new FakeBackend);
+    std::unique_ptr<QuotaReservationManager::QuotaBackend> backend(
+        new FakeBackend);
     reservation_manager_.reset(new QuotaReservationManager(std::move(backend)));
   }
 
   void TearDown() override { reservation_manager_.reset(); }
 
   FakeBackend* fake_backend() {
     return static_cast<FakeBackend*>(reservation_manager_->backend_.get());
   }
 
   QuotaReservationManager* reservation_manager() {
     return reservation_manager_.get();
   }
 
   const base::FilePath& file_path() const {
     return file_path_;
   }
 
  private:
   base::MessageLoop message_loop_;
   base::ScopedTempDir work_dir_;
   base::FilePath file_path_;
-  scoped_ptr<QuotaReservationManager> reservation_manager_;
+  std::unique_ptr<QuotaReservationManager> reservation_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaReservationManagerTest);
 };
 
 TEST_F(QuotaReservationManagerTest, BasicTest) {
   scoped_refptr<QuotaReservation> reservation =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 3);
@@ skipping 70 matching lines @@
   scoped_refptr<QuotaReservation> reservation1 =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
   RefreshReservation(reservation1.get(), 10);
   int64_t cached_reserved_quota1 = reservation1->remaining_quota();
 
   scoped_refptr<QuotaReservation> reservation2 =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
   RefreshReservation(reservation2.get(), 20);
   int64_t cached_reserved_quota2 = reservation2->remaining_quota();
 
-  scoped_ptr<FakeWriter> writer1(
+  std::unique_ptr<FakeWriter> writer1(
       new FakeWriter(reservation1->GetOpenFileHandle(file_path())));
 
-  scoped_ptr<FakeWriter> writer2(
+  std::unique_ptr<FakeWriter> writer2(
       new FakeWriter(reservation2->GetOpenFileHandle(file_path())));
 
   cached_reserved_quota1 -= writer1->Write(kInitialFileSize + 10);
   EXPECT_LE(0, cached_reserved_quota1);
 
   cached_reserved_quota2 -= writer2->Append(20);
   EXPECT_LE(0, cached_reserved_quota2);
 
   writer1->ReportUsage();
   RefreshReservation(reservation1.get(), 2);
@@ skipping 39 matching lines @@
 
   EXPECT_EQ(kInitialFileSize + 10, GetFileSize(file_path()));
   EXPECT_EQ(kInitialFileSize + 15 + 20, fake_backend()->on_memory_usage());
   EXPECT_EQ(kInitialFileSize + 10, fake_backend()->on_disk_usage());
 
   reservation2 = NULL;
   EXPECT_EQ(kInitialFileSize + 10, fake_backend()->on_memory_usage());
 }
 
 }  // namespace content