chrome/browser/media_galleries/media_folder_finder_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/media_galleries/media_folder_finder.h"
   6
   7 #include <set>
   8 #include <string>
   9
  10 #include "base/base_paths.h"
  11 #include "base/bind.h"
  12 #include "base/files/file_util.h"
  13 #include "base/files/scoped_temp_dir.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/test/scoped_path_override.h"
  16 #include "base/threading/sequenced_worker_pool.h"
  17 #include "chrome/browser/media_galleries/media_scan_types.h"
  18 #include "chrome/common/chrome_paths.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "content/public/test/test_browser_thread_bundle.h"
  21 #include "content/public/test/test_utils.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 class MediaFolderFinderTest : public testing::Test {
  25  public:
  26   MediaFolderFinderTest() {
  27   }
  28
  29   ~MediaFolderFinderTest() override {}
  30
  31   void SetUp() override { ASSERT_TRUE(fake_dir_.CreateUniqueTempDir()); }
  32
  33   void TearDown() override { ASSERT_EQ(NULL, media_folder_finder_.get()); }
  34
  35  protected:
  36   void CreateMediaFolderFinder(
  37       const std::vector<base::FilePath> roots,
  38       bool expected_success,
  39       const MediaFolderFinder::MediaFolderFinderResults& expected_results) {
  40     EXPECT_EQ(NULL, media_folder_finder_.get());
  41     received_results_ = false;
  42     expected_success_ = expected_success;
  43     expected_results_ = expected_results;
  44     media_folder_finder_.reset(
  45         new MediaFolderFinder(base::Bind(&MediaFolderFinderTest::OnGotResults,
  46                                          base::Unretained(this))));
  47     media_folder_finder_->SetRootsForTesting(roots);
  48   }
  49
  50   void StartScan() {
  51     media_folder_finder_->StartScan();
  52   }
  53
  54   void DeleteMediaFolderFinder() {
  55     EXPECT_TRUE(media_folder_finder_.get() != NULL);
  56     media_folder_finder_.reset();
  57   }
  58
  59   bool received_results() const {
  60     return received_results_;
  61   }
  62
  63   const base::FilePath& fake_dir() const {
  64     return fake_dir_.path();
  65   }
  66
  67   void CreateTestDir(const base::FilePath& parent_dir) {
  68     if (parent_dir == fake_dir())
  69       return;
  70
  71     ASSERT_TRUE(fake_dir().IsParent(parent_dir));
  72     ASSERT_TRUE(base::CreateDirectory(parent_dir));
  73   }
  74
  75   void CreateTestFile(const base::FilePath& parent_dir,
  76                       MediaGalleryScanFileType type,
  77                       size_t count,
  78                       bool big,
  79                       MediaFolderFinder::MediaFolderFinderResults* results) {
  80     CreateTestDir(parent_dir);
  81
  82     std::string extension;
  83     size_t filesize;
  84     MediaGalleryScanResult& result = (*results)[parent_dir];
  85     switch (type) {
  86       case MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE:
  87         extension = "jpg";
  88         filesize = 10;
  89         result.image_count += count;
  90         break;
  91       case MEDIA_GALLERY_SCAN_FILE_TYPE_AUDIO:
  92         extension = "wav";
  93         filesize = 20;
  94         result.audio_count += count;
  95         break;
  96       case MEDIA_GALLERY_SCAN_FILE_TYPE_VIDEO:
  97         extension = "avi";
  98         filesize = 30;
  99         result.video_count += count;
 100         break;
 101       case MEDIA_GALLERY_SCAN_FILE_TYPE_UNKNOWN:
 102         extension = "txt";
 103         filesize = 10;
 104         if (IsEmptyScanResult(result))
 105           results->erase(parent_dir);
 106         break;
 107       default:
 108         NOTREACHED();
 109         return;
 110     }
 111     if (big)
 112       filesize *= 100000;
 113
 114     for (size_t i = 0; i < count; ++i) {
 115       base::FilePath test_file(parent_dir.AppendASCII("dummy." + extension));
 116       int uniquifier =
 117           base::GetUniquePathNumber(test_file, base::FilePath::StringType());
 118       if (uniquifier > 0) {
 119         test_file = test_file.InsertBeforeExtensionASCII(
 120             base::StringPrintf(" (%d)", uniquifier));
 121         filesize += uniquifier;
 122       }
 123
 124       std::string dummy_data;
 125       dummy_data.resize(filesize);
 126
 127       int bytes_written =
 128           base::WriteFile(test_file, dummy_data.c_str(), filesize);
 129       ASSERT_GE(bytes_written, 0);
 130       ASSERT_EQ(filesize, static_cast<size_t>(bytes_written));
 131     }
 132   }
 133
 134   void RunLoopUntilReceivedCallback() {
 135     while (!received_results())
 136       content::RunAllBlockingPoolTasksUntilIdle();
 137   }
 138
 139  private:
 140   void OnGotResults(
 141       bool success,
 142       const MediaFolderFinder::MediaFolderFinderResults& results) {
 143     received_results_ = true;
 144     EXPECT_EQ(expected_success_, success);
 145     std::set<base::FilePath> expected_keys =
 146         GetKeysFromResults(expected_results_);
 147     ASSERT_EQ(expected_keys, GetKeysFromResults(results));
 148     for (MediaFolderFinder::MediaFolderFinderResults::const_iterator it =
 149              results.begin();
 150          it != results.end(); ++it) {
 151       const base::FilePath& folder = it->first;
 152       const MediaGalleryScanResult& expected = it->second;
 153       const MediaGalleryScanResult& actual = results.find(folder)->second;
 154       EXPECT_EQ(expected.image_count, actual.image_count)
 155           << " Image count for " << folder.value();
 156       EXPECT_EQ(expected.audio_count, actual.audio_count)
 157           << " Audio count for " << folder.value();
 158       EXPECT_EQ(expected.video_count, actual.video_count)
 159           << " Video count for " << folder.value();
 160     }
 161   }
 162
 163   std::set<base::FilePath> GetKeysFromResults(
 164       const MediaFolderFinder::MediaFolderFinderResults& results) {
 165     std::set<base::FilePath> keys;
 166     for (MediaFolderFinder::MediaFolderFinderResults::const_iterator it =
 167              results.begin();
 168          it != results.end(); ++it) {
 169       keys.insert(it->first);
 170     }
 171     return keys;
 172   }
 173
 174   content::TestBrowserThreadBundle thread_bundle_;
 175
 176   base::ScopedTempDir fake_dir_;
 177
 178   scoped_ptr<MediaFolderFinder> media_folder_finder_;
 179
 180   bool expected_success_;
 181   MediaFolderFinder::MediaFolderFinderResults expected_results_;
 182   bool received_results_;
 183
 184   DISALLOW_COPY_AND_ASSIGN(MediaFolderFinderTest);
 185 };
 186
 187 TEST_F(MediaFolderFinderTest, NoScan) {
 188   MediaFolderFinder::MediaFolderFinderResults expected_results;
 189   std::vector<base::FilePath> folders;
 190   folders.push_back(fake_dir());
 191   CreateMediaFolderFinder(folders, false, expected_results);
 192   DeleteMediaFolderFinder();
 193   EXPECT_TRUE(received_results());
 194 }
 195
 196 TEST_F(MediaFolderFinderTest, ScanAndCancel) {
 197   MediaFolderFinder::MediaFolderFinderResults expected_results;
 198   std::vector<base::FilePath> folders;
 199   folders.push_back(fake_dir());
 200   CreateMediaFolderFinder(folders, false, expected_results);
 201   StartScan();
 202   DeleteMediaFolderFinder();
 203   content::RunAllBlockingPoolTasksUntilIdle();
 204   EXPECT_TRUE(received_results());
 205 }
 206
 207 TEST_F(MediaFolderFinderTest, ScanNothing) {
 208   MediaFolderFinder::MediaFolderFinderResults expected_results;
 209   std::vector<base::FilePath> folders;
 210   CreateMediaFolderFinder(folders, true, expected_results);
 211   StartScan();
 212   RunLoopUntilReceivedCallback();
 213   DeleteMediaFolderFinder();
 214 }
 215
 216 TEST_F(MediaFolderFinderTest, EmptyScan) {
 217   MediaFolderFinder::MediaFolderFinderResults expected_results;
 218   std::vector<base::FilePath> folders;
 219   folders.push_back(fake_dir());
 220   CreateMediaFolderFinder(folders, true, expected_results);
 221   StartScan();
 222   RunLoopUntilReceivedCallback();
 223   DeleteMediaFolderFinder();
 224 }
 225
 226 TEST_F(MediaFolderFinderTest, ScanMediaFiles) {
 227   MediaFolderFinder::MediaFolderFinderResults expected_results;
 228   std::vector<base::FilePath> folders;
 229   folders.push_back(fake_dir());
 230
 231   base::FilePath dir1 = fake_dir().AppendASCII("dir1");
 232   base::FilePath dir2 = fake_dir().AppendASCII("dir2");
 233   base::FilePath dir2_3 = dir2.AppendASCII("dir2_3");
 234   base::FilePath dir2_4 = dir2.AppendASCII("dir2_4");
 235   base::FilePath dir2_4_5 = dir2_4.AppendASCII("dir2_4_5");
 236   base::FilePath dir2_4_empty = dir2_4.AppendASCII("dir2_4_empty");
 237   base::FilePath dir_empty = fake_dir().AppendASCII("dir_empty");
 238
 239   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 2, true,
 240                  &expected_results);
 241   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, false,
 242                  &expected_results);
 243   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_UNKNOWN, 1, false,
 244                  &expected_results);
 245   CreateTestFile(dir2_3, MEDIA_GALLERY_SCAN_FILE_TYPE_AUDIO, 4, true,
 246                  &expected_results);
 247   CreateTestFile(dir2_3, MEDIA_GALLERY_SCAN_FILE_TYPE_AUDIO, 3, false,
 248                  &expected_results);
 249   CreateTestFile(dir2_4, MEDIA_GALLERY_SCAN_FILE_TYPE_UNKNOWN, 5, false,
 250                  &expected_results);
 251   CreateTestFile(dir2_4_5, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 2, true,
 252                  &expected_results);
 253   CreateTestFile(dir2_4_5, MEDIA_GALLERY_SCAN_FILE_TYPE_AUDIO, 4, true,
 254                  &expected_results);
 255   CreateTestFile(dir2_4_5, MEDIA_GALLERY_SCAN_FILE_TYPE_VIDEO, 1, true,
 256                  &expected_results);
 257   CreateTestFile(dir2_4_5, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 5, false,
 258                  &expected_results);
 259   CreateTestFile(dir2_4_5, MEDIA_GALLERY_SCAN_FILE_TYPE_VIDEO, 3, false,
 260                  &expected_results);
 261   CreateTestFile(dir2_4_5, MEDIA_GALLERY_SCAN_FILE_TYPE_UNKNOWN, 3, true,
 262                  &expected_results);
 263   CreateTestDir(dir2_4_empty);
 264   CreateTestDir(dir_empty);
 265
 266   CreateMediaFolderFinder(folders, true, expected_results);
 267   StartScan();
 268   RunLoopUntilReceivedCallback();
 269   DeleteMediaFolderFinder();
 270 }
 271
 272 TEST_F(MediaFolderFinderTest, SkipHiddenFiles) {
 273   MediaFolderFinder::MediaFolderFinderResults expected_results;
 274   std::vector<base::FilePath> folders;
 275   folders.push_back(fake_dir());
 276
 277   base::FilePath hidden_dir = fake_dir().AppendASCII(".hidden");
 278
 279   CreateTestFile(hidden_dir, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 2, true,
 280                  &expected_results);
 281   expected_results.erase(hidden_dir);
 282
 283   CreateMediaFolderFinder(folders, true, expected_results);
 284   StartScan();
 285   RunLoopUntilReceivedCallback();
 286   DeleteMediaFolderFinder();
 287 }
 288
 289 TEST_F(MediaFolderFinderTest, ScanIgnoresSmallMediaFiles) {
 290   MediaFolderFinder::MediaFolderFinderResults expected_results;
 291   std::vector<base::FilePath> folders;
 292   folders.push_back(fake_dir());
 293
 294   base::FilePath dir1 = fake_dir().AppendASCII("dir1");
 295   base::FilePath dir2 = fake_dir().AppendASCII("dir2");
 296   base::FilePath dir_empty = fake_dir().AppendASCII("dir_empty");
 297
 298   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 2, true,
 299                  &expected_results);
 300   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_VIDEO, 1, false,
 301                  &expected_results);
 302   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_UNKNOWN, 1, false,
 303                  &expected_results);
 304   CreateTestFile(dir2, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, false,
 305                  &expected_results);
 306   CreateTestFile(dir2, MEDIA_GALLERY_SCAN_FILE_TYPE_AUDIO, 3, false,
 307                  &expected_results);
 308   CreateTestFile(dir2, MEDIA_GALLERY_SCAN_FILE_TYPE_VIDEO, 5, false,
 309                  &expected_results);
 310   CreateTestFile(dir2, MEDIA_GALLERY_SCAN_FILE_TYPE_UNKNOWN, 1, true,
 311                  &expected_results);
 312   CreateTestDir(dir_empty);
 313   ASSERT_EQ(1U, expected_results.erase(dir2));
 314
 315   CreateMediaFolderFinder(folders, true, expected_results);
 316   StartScan();
 317   RunLoopUntilReceivedCallback();
 318   DeleteMediaFolderFinder();
 319 }
 320
 321 TEST_F(MediaFolderFinderTest, Overlap) {
 322   MediaFolderFinder::MediaFolderFinderResults expected_results;
 323   std::vector<base::FilePath> folders;
 324   folders.push_back(fake_dir());
 325   folders.push_back(fake_dir());
 326
 327   base::FilePath dir1 = fake_dir().AppendASCII("dir1");
 328   folders.push_back(dir1);
 329   folders.push_back(dir1);
 330
 331   CreateTestFile(dir1, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 332                  &expected_results);
 333
 334   CreateMediaFolderFinder(folders, true, expected_results);
 335   StartScan();
 336   RunLoopUntilReceivedCallback();
 337   DeleteMediaFolderFinder();
 338 }
 339
 340 TEST_F(MediaFolderFinderTest, Prune) {
 341   MediaFolderFinder::MediaFolderFinderResults expected_results;
 342   std::vector<base::FilePath> folders;
 343   folders.push_back(fake_dir());
 344
 345 #if defined(OS_WIN)
 346   int pruned_dir_key = base::DIR_IE_INTERNET_CACHE;
 347 #elif defined(OS_MACOSX)
 348   int pruned_dir_key = chrome::DIR_USER_LIBRARY;
 349 #else
 350   int pruned_dir_key = base::DIR_CACHE;
 351 #endif
 352
 353   base::FilePath fake_pruned_dir = fake_dir().AppendASCII("dir1");
 354   base::ScopedPathOverride scoped_fake_pruned_dir_override(pruned_dir_key,
 355                                                            fake_pruned_dir);
 356
 357   CreateTestFile(fake_dir(), MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 358                  &expected_results);
 359   CreateTestFile(fake_pruned_dir, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 360                  &expected_results);
 361
 362   base::FilePath test_dir = fake_pruned_dir.AppendASCII("dir2");
 363   CreateTestFile(test_dir, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 364                  &expected_results);
 365
 366   // |fake_pruned_dir| and |test_dir| are pruned.
 367   expected_results.erase(fake_pruned_dir);
 368   expected_results.erase(test_dir);
 369
 370   CreateMediaFolderFinder(folders, true, expected_results);
 371   StartScan();
 372   RunLoopUntilReceivedCallback();
 373   DeleteMediaFolderFinder();
 374 }
 375
 376 TEST_F(MediaFolderFinderTest, Graylist) {
 377   MediaFolderFinder::MediaFolderFinderResults expected_results;
 378   std::vector<base::FilePath> folders;
 379   folders.push_back(fake_dir());
 380
 381   base::FilePath fake_home_dir = fake_dir().AppendASCII("dir1");
 382   base::FilePath test_dir = fake_home_dir.AppendASCII("dir2");
 383   base::ScopedPathOverride scoped_fake_home_dir_override(base::DIR_HOME,
 384                                                          fake_home_dir);
 385
 386   CreateTestFile(fake_dir(), MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 387                  &expected_results);
 388   CreateTestFile(fake_home_dir, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 389                  &expected_results);
 390   CreateTestFile(test_dir, MEDIA_GALLERY_SCAN_FILE_TYPE_IMAGE, 1, true,
 391                  &expected_results);
 392
 393   // |fake_home_dir| and its ancestors do not show up in results.
 394   expected_results.erase(fake_dir());
 395   expected_results.erase(fake_home_dir);
 396
 397   CreateMediaFolderFinder(folders, true, expected_results);
 398   StartScan();
 399   RunLoopUntilReceivedCallback();
 400   DeleteMediaFolderFinder();
 401 }