Remove ScopedVector from ContentBrowserClient.

chrome/browser/media_galleries/fileapi/picasa_file_util_unittest.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/media_galleries/fileapi/picasa_file_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
 #include "chrome/browser/media_galleries/fileapi/picasa_data_provider.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
@@ skipping 205 matching lines @@
     ImportedMediaGalleryRegistry::GetInstance()->Initialize();
 
     scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
         new content::MockSpecialStoragePolicy();
 
     SynchronouslyRunOnMediaTaskRunner(base::Bind(
         &PicasaFileUtilTest::SetUpOnMediaTaskRunner, base::Unretained(this)));
 
     media_path_filter_.reset(new MediaPathFilter());
 
-    ScopedVector<storage::FileSystemBackend> additional_providers;
-    additional_providers.push_back(new TestMediaFileSystemBackend(
+    std::vector<std::unique_ptr<storage::FileSystemBackend>>
+        additional_providers;
+    additional_providers.push_back(base::MakeUnique<TestMediaFileSystemBackend>(
         profile_dir_.GetPath(),
         new TestPicasaFileUtil(media_path_filter_.get(),
                                picasa_data_provider_.get())));
 
     file_system_context_ = new storage::FileSystemContext(
         base::ThreadTaskRunnerHandle::Get().get(),
         base::ThreadTaskRunnerHandle::Get().get(),
         storage::ExternalMountPoints::CreateRefCounted().get(),
         storage_policy.get(), NULL, std::move(additional_providers),
         std::vector<storage::URLRequestAutoMountHandler>(),
         profile_dir_.GetPath(), content::CreateAllowFileAccessOptions());
   }
 
   void TearDown() override {
     SynchronouslyRunOnMediaTaskRunner(
         base::Bind(&PicasaFileUtilTest::TearDownOnMediaTaskRunner,
                    base::Unretained(this)));
   }
 
  protected:
   void SetUpOnMediaTaskRunner() {
     picasa_data_provider_.reset(new PicasaDataProvider(base::FilePath()));
   }
 
   void TearDownOnMediaTaskRunner() {
     picasa_data_provider_.reset();
   }
 
   // |test_folders| must be in alphabetical order for easy verification
-  void SetupFolders(ScopedVector<TestFolder>* test_folders,
+  void SetupFolders(std::vector<std::unique_ptr<TestFolder>>* test_folders,
                     const std::vector<AlbumInfo>& albums,
                     const AlbumImagesMap& albums_images) {
     std::vector<AlbumInfo> folders;
-    for (ScopedVector<TestFolder>::iterator it = test_folders->begin();
-        it != test_folders->end(); ++it) {
-      TestFolder* test_folder = *it;
+    for (const auto& test_folder : *test_folders) {
       ASSERT_TRUE(test_folder->Init());
       folders.push_back(test_folder->folder_info());
     }
 
     PicasaDataProvider::UniquifyNames(albums,
                                       &picasa_data_provider_->album_map_);
     PicasaDataProvider::UniquifyNames(folders,
                                       &picasa_data_provider_->folder_map_);
     picasa_data_provider_->albums_images_ = albums_images;
     picasa_data_provider_->state_ =
         PicasaDataProvider::ALBUMS_IMAGES_FRESH_STATE;
   }
 
-  void VerifyFolderDirectoryList(const ScopedVector<TestFolder>& test_folders) {
+  void VerifyFolderDirectoryList(
+      const std::vector<std::unique_ptr<TestFolder>>& test_folders) {
     FileSystemOperation::FileEntryList contents;
     FileSystemURL url = CreateURL(kPicasaDirFolders);
     bool completed = false;
     ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
     ASSERT_TRUE(completed);
     ASSERT_EQ(test_folders.size(), contents.size());
 
     for (size_t i = 0; i < contents.size(); ++i) {
       EXPECT_TRUE(contents[i].is_directory);
 
       FileSystemOperation::FileEntryList folder_contents;
       FileSystemURL folder_url = CreateURL(
           std::string(kPicasaDirFolders) + "/" +
           base::FilePath(contents[i].name).AsUTF8Unsafe());
       bool folder_read_completed = false;
       ReadDirectoryTestHelper(operation_runner(), folder_url, &folder_contents,
                               &folder_read_completed);
 
       EXPECT_TRUE(folder_read_completed);
 
       const std::set<std::string>& image_filenames =
           test_folders[i]->image_filenames();
 
       EXPECT_EQ(image_filenames.size(), folder_contents.size());
 
-      for (FileSystemOperation::FileEntryList::const_iterator file_it =
-               folder_contents.begin(); file_it != folder_contents.end();
-           ++file_it) {
+      for (auto file_it = folder_contents.begin();
+           file_it != folder_contents.end(); ++file_it) {
         EXPECT_EQ(1u, image_filenames.count(
             base::FilePath(file_it->name).AsUTF8Unsafe()));
       }
     }
   }
 
   std::string DateToPathString(const base::Time& time) {
     return PicasaDataProvider::DateToPathString(time);
   }
 
@@ skipping 55 matching lines @@
 
   base::Time::Exploded exploded_shortday = { 2013, 11, 0, 3, 0, 0, 0, 0 };
   base::Time shortday;
   EXPECT_TRUE(base::Time::FromLocalExploded(exploded_shortday, &shortday));
 
   EXPECT_EQ("2013-04-16", DateToPathString(shortmonth));
   EXPECT_EQ("2013-11-03", DateToPathString(shortday));
 }
 
 TEST_F(PicasaFileUtilTest, NameDeduplication) {
-  ScopedVector<TestFolder> test_folders;
+  std::vector<std::unique_ptr<TestFolder>> test_folders;
   std::vector<std::string> expected_names;
 
   base::Time test_date;
   EXPECT_TRUE(base::Time::FromLocalExploded(test_date_exploded, &test_date));
   base::Time test_date_2 = test_date - base::TimeDelta::FromDays(1);
 
   std::string test_date_string = DateToPathString(test_date);
   std::string test_date_2_string = DateToPathString(test_date_2);
 
   test_folders.push_back(
-      new TestFolder("diff_date", test_date_2, "uuid3", 0, 0));
+      base::MakeUnique<TestFolder>("diff_date", test_date_2, "uuid3", 0, 0));
   expected_names.push_back("diff_date " + test_date_2_string);
 
   test_folders.push_back(
-      new TestFolder("diff_date", test_date, "uuid2", 0, 0));
+      base::MakeUnique<TestFolder>("diff_date", test_date, "uuid2", 0, 0));
   expected_names.push_back("diff_date " + test_date_string);
 
   test_folders.push_back(
-      new TestFolder("duplicate", test_date, "uuid4", 0, 0));
+      base::MakeUnique<TestFolder>("duplicate", test_date, "uuid4", 0, 0));
   expected_names.push_back("duplicate " + test_date_string + " (1)");
 
   test_folders.push_back(
-      new TestFolder("duplicate", test_date, "uuid5", 0, 0));
+      base::MakeUnique<TestFolder>("duplicate", test_date, "uuid5", 0, 0));
   expected_names.push_back("duplicate " + test_date_string + " (2)");
 
   test_folders.push_back(
-      new TestFolder("unique_name", test_date, "uuid1", 0, 0));
+      base::MakeUnique<TestFolder>("unique_name", test_date, "uuid1", 0, 0));
   expected_names.push_back("unique_name " + test_date_string);
 
   SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
 
   FileSystemOperation::FileEntryList contents;
   FileSystemURL url = CreateURL(kPicasaDirFolders);
   bool completed = false;
   ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
   ASSERT_TRUE(completed);
   ASSERT_EQ(expected_names.size(), contents.size());
   for (size_t i = 0; i < contents.size(); ++i) {
     EXPECT_EQ(expected_names[i],
               base::FilePath(contents[i].name).AsUTF8Unsafe());
     EXPECT_TRUE(contents[i].is_directory);
   }
 }
 
 TEST_F(PicasaFileUtilTest, RootFolders) {
-  ScopedVector<TestFolder> empty_folders_list;
+  std::vector<std::unique_ptr<TestFolder>> empty_folders_list;
   SetupFolders(&empty_folders_list, std::vector<AlbumInfo>(), AlbumImagesMap());
 
   FileSystemOperation::FileEntryList contents;
   FileSystemURL url = CreateURL("");
   bool completed = false;
   ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
 
   ASSERT_TRUE(completed);
   ASSERT_EQ(2u, contents.size());
 
   EXPECT_TRUE(contents.front().is_directory);
   EXPECT_TRUE(contents.back().is_directory);
 
   EXPECT_EQ(FILE_PATH_LITERAL("albums"), contents.front().name);
   EXPECT_EQ(FILE_PATH_LITERAL("folders"), contents.back().name);
 }
 
 TEST_F(PicasaFileUtilTest, NonexistentFolder) {
-  ScopedVector<TestFolder> empty_folders_list;
+  std::vector<std::unique_ptr<TestFolder>> empty_folders_list;
   SetupFolders(&empty_folders_list, std::vector<AlbumInfo>(), AlbumImagesMap());
 
   TestNonexistentDirectory(std::string(kPicasaDirFolders) + "/foo");
   TestNonexistentDirectory(std::string(kPicasaDirFolders) + "/foo/bar");
   TestNonexistentDirectory(std::string(kPicasaDirFolders) + "/foo/bar/baz");
 }
 
 TEST_F(PicasaFileUtilTest, FolderContentsTrivial) {
-  ScopedVector<TestFolder> test_folders;
+  std::vector<std::unique_ptr<TestFolder>> test_folders;
   base::Time test_date;
   EXPECT_TRUE(base::Time::FromLocalExploded(test_date_exploded, &test_date));
 
-  test_folders.push_back(
-      new TestFolder("folder-1-empty", test_date, "uid-empty", 0, 0));
-  test_folders.push_back(
-      new TestFolder("folder-2-images", test_date, "uid-images", 5, 0));
-  test_folders.push_back(
-      new TestFolder("folder-3-nonimages", test_date, "uid-nonimages", 0, 5));
-  test_folders.push_back(
-      new TestFolder("folder-4-both", test_date, "uid-both", 5, 5));
+  test_folders.push_back(base::MakeUnique<TestFolder>(
+      "folder-1-empty", test_date, "uid-empty", 0, 0));
+  test_folders.push_back(base::MakeUnique<TestFolder>(
+      "folder-2-images", test_date, "uid-images", 5, 0));
+  test_folders.push_back(base::MakeUnique<TestFolder>(
+      "folder-3-nonimages", test_date, "uid-nonimages", 0, 5));
+  test_folders.push_back(base::MakeUnique<TestFolder>(
+      "folder-4-both", test_date, "uid-both", 5, 5));
 
   SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
   VerifyFolderDirectoryList(test_folders);
 }
 
 TEST_F(PicasaFileUtilTest, FolderWithManyFiles) {
-  ScopedVector<TestFolder> test_folders;
+  std::vector<std::unique_ptr<TestFolder>> test_folders;
   base::Time test_date;
   EXPECT_TRUE(base::Time::FromLocalExploded(test_date_exploded, &test_date));
 
-  test_folders.push_back(
-      new TestFolder("folder-many-files", test_date, "uid-both", 50, 50));
+  test_folders.push_back(base::MakeUnique<TestFolder>(
+      "folder-many-files", test_date, "uid-both", 50, 50));
 
   SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
   VerifyFolderDirectoryList(test_folders);
 }
 
 TEST_F(PicasaFileUtilTest, ManyFolders) {
-  ScopedVector<TestFolder> test_folders;
+  std::vector<std::unique_ptr<TestFolder>> test_folders;
   base::Time test_date;
   EXPECT_TRUE(base::Time::FromLocalExploded(test_date_exploded, &test_date));
 
   for (unsigned int i = 0; i < 50; ++i) {
     base::Time date = test_date - base::TimeDelta::FromDays(i);
 
-    test_folders.push_back(
-        new TestFolder(base::StringPrintf("folder-%05d", i),
-                       date,
-                       base::StringPrintf("uid%05d", i), i % 5, i % 3));
+    test_folders.push_back(base::MakeUnique<TestFolder>(
+        base::StringPrintf("folder-%05d", i), date,
+        base::StringPrintf("uid%05d", i), i % 5, i % 3));
   }
 
   SetupFolders(&test_folders, std::vector<AlbumInfo>(), AlbumImagesMap());
   VerifyFolderDirectoryList(test_folders);
 }
 
 TEST_F(PicasaFileUtilTest, AlbumExistence) {
-  ScopedVector<TestFolder> test_folders;
+  std::vector<std::unique_ptr<TestFolder>> test_folders;
   base::Time test_date;
   EXPECT_TRUE(base::Time::FromLocalExploded(test_date_exploded, &test_date));
 
   std::vector<AlbumInfo> albums;
   AlbumInfo info;
   info.name = "albumname";
   info.uid = "albumuid";
   info.timestamp = test_date;
   albums.push_back(info);
 
   AlbumImagesMap albums_images;
   albums_images[info.uid] = AlbumImages();
 
   SetupFolders(&test_folders, albums, albums_images);
 
   TestEmptyDirectory(std::string(kPicasaDirAlbums) + "/albumname 2013-04-16");
   TestNonexistentDirectory(std::string(kPicasaDirAlbums) +
                            "/albumname 2013-04-16/toodeep");
   TestNonexistentDirectory(std::string(kPicasaDirAlbums) + "/wrongname");
 }
 
 TEST_F(PicasaFileUtilTest, AlbumContents) {
-  ScopedVector<TestFolder> test_folders;
+  std::vector<std::unique_ptr<TestFolder>> test_folders;
   base::Time test_date;
   EXPECT_TRUE(base::Time::FromLocalExploded(test_date_exploded, &test_date));
 
   std::vector<AlbumInfo> albums;
   AlbumInfo info;
   info.name = "albumname";
   info.uid = "albumuid";
   info.timestamp = test_date;
   albums.push_back(info);
 
@@ skipping 33 matching lines @@
   operation_runner()->CreateSnapshotFile(
       CreateURL(std::string(kPicasaDirAlbums) +
                 "/albumname 2013-04-16/mapped_name.jpg"),
       snapshot_callback);
   loop.Run();
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(image_path, platform_path_result);
 }
 
 }  // namespace picasa