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

chrome/browser/chromeos/base/file_flusher_unittest.cc

 // Copyright 2016 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/chromeos/base/file_flusher.h"
 
 #include <map>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 30 matching lines @@
         WriteStringToFile(temp_dir_.path().AppendASCII(path), content);
       }
     }
   }
 
   void TearDown() override {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   }
 
-  scoped_ptr<FileFlusher> CreateFileFlusher() {
-    scoped_ptr<FileFlusher> flusher(new FileFlusher);
+  std::unique_ptr<FileFlusher> CreateFileFlusher() {
+    std::unique_ptr<FileFlusher> flusher(new FileFlusher);
     flusher->set_on_flush_callback_for_test(
         base::Bind(&FileFlusherTest::OnFlush, base::Unretained(this)));
     return flusher;
   }
 
   base::FilePath GetTestFilePath(const std::string& path_string) const {
     const base::FilePath path = base::FilePath::FromUTF8Unsafe(path_string);
     if (path.IsAbsolute())
       return path;
 
@@ skipping 10 matching lines @@
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
   std::map<base::FilePath, int> flush_counts_;
 
   DISALLOW_COPY_AND_ASSIGN(FileFlusherTest);
 };
 
 TEST_F(FileFlusherTest, Flush) {
-  scoped_ptr<FileFlusher> flusher(CreateFileFlusher());
+  std::unique_ptr<FileFlusher> flusher(CreateFileFlusher());
   base::RunLoop run_loop;
   flusher->RequestFlush(GetTestFilePath("dir1"), std::vector<base::FilePath>(),
                         base::Closure());
   flusher->RequestFlush(GetTestFilePath("dir2"), std::vector<base::FilePath>(),
                         run_loop.QuitClosure());
   run_loop.Run();
 
   EXPECT_EQ(1, GetFlushCount("dir1/file1"));
   EXPECT_EQ(1, GetFlushCount("dir1/file2"));
   EXPECT_EQ(1, GetFlushCount("dir1/file3"));
 
   EXPECT_EQ(1, GetFlushCount("dir2/file1"));
   EXPECT_EQ(1, GetFlushCount("dir2/file2"));
   EXPECT_EQ(1, GetFlushCount("dir2/file3"));
 }
 
 TEST_F(FileFlusherTest, Exclude) {
-  scoped_ptr<FileFlusher> flusher(CreateFileFlusher());
+  std::unique_ptr<FileFlusher> flusher(CreateFileFlusher());
 
   std::vector<base::FilePath> excludes;
   // Relative exclude
   excludes.push_back(base::FilePath::FromUTF8Unsafe("file1"));
   // Absolute exclude
   excludes.push_back(GetTestFilePath("dir1/file2"));
   // Invalid exclude will be ignored.
   excludes.push_back(base::FilePath::FromUTF8Unsafe("Bad file"));
 
   base::RunLoop run_loop;
   flusher->RequestFlush(GetTestFilePath("dir1"), excludes,
                         run_loop.QuitClosure());
   run_loop.Run();
 
   EXPECT_EQ(0, GetFlushCount("dir1/file1"));
   EXPECT_EQ(0, GetFlushCount("dir1/file2"));
   EXPECT_EQ(1, GetFlushCount("dir1/file3"));
 
   EXPECT_EQ(0, GetFlushCount("dir1/Bad file"));
 }
 
 TEST_F(FileFlusherTest, DuplicateRequests) {
-  scoped_ptr<FileFlusher> flusher(CreateFileFlusher());
+  std::unique_ptr<FileFlusher> flusher(CreateFileFlusher());
   base::RunLoop run_loop;
   flusher->RequestFlush(GetTestFilePath("dir1"), std::vector<base::FilePath>(),
                         base::Closure());
   flusher->RequestFlush(GetTestFilePath("dir1"), std::vector<base::FilePath>(),
                         run_loop.QuitClosure());
   run_loop.Run();
 
   EXPECT_EQ(1, GetFlushCount("dir1/file1"));
   EXPECT_EQ(1, GetFlushCount("dir1/file2"));
   EXPECT_EQ(1, GetFlushCount("dir1/file3"));
 }
 
 }  // namespace chromeos