Have FindContainerScanResults() find broader media container directories

chrome/browser/media_galleries/media_scan_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 "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 212 matching lines @@
       EXPECT_TRUE(false);
       return;
     }
     MediaGalleriesPrefInfoMap::const_iterator pref_info =
         known_galleries().find(pref_id);
     EXPECT_EQ(audio_count, pref_info->second.audio_count);
     EXPECT_EQ(image_count, pref_info->second.image_count);
     EXPECT_EQ(video_count, pref_info->second.video_count);
   }
 
-  // MediaScanMangerObserver implementation.
+  // MediaScanManagerObserver implementation.
   virtual void OnScanFinished(
       const std::string& extension_id,
       int gallery_count,
       const MediaGalleryScanResult& file_counts) OVERRIDE {
     EXPECT_EQ(extension_->id(), extension_id);
     EXPECT_EQ(expected_gallery_count_, gallery_count);
     EXPECT_EQ(expected_file_counts_.audio_count, file_counts.audio_count);
     EXPECT_EQ(expected_file_counts_.image_count, file_counts.image_count);
     EXPECT_EQ(expected_file_counts_.video_count, file_counts.video_count);
   }
 
+ protected:
+  // So derived tests can access ...::FindContainerScanResults().
+  MediaFolderFinder::MediaFolderFinderResults FindContainerScanResults(
+      const MediaFolderFinder::MediaFolderFinderResults& found_folders,
+      const std::vector<base::FilePath>& sensitive_locations) {
+    return MediaScanManager::FindContainerScanResults(found_folders,
+                                                      sensitive_locations);
+  }
+
  private:
   void OnFindFoldersStarted(
       MediaFolderFinder::MediaFolderFinderResultsCallback callback) {
     find_folders_start_count_++;
     callback.Run(find_folders_success_, find_folders_results_);
   }
 
   void OnFindFoldersDestroyed() {
     find_folders_destroy_count_++;
   }
@@ skipping 44 matching lines @@
   SetFindFoldersResults(true, found_folders);
 
   SetExpectedScanResults(1 /*gallery_count*/, file_counts);
   StartScan();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, FindFolderDestroyCount());
   EXPECT_EQ(galleries_before + 1, gallery_count());
 }
 
+// Generally test that it includes directories with sufficient density
+// and excludes others.
+//
+// A/ - NOT included
+// A/B/ - NOT included
+// A/B/C/files
+// A/D/ - NOT included
+// A/D/E/files
+// A/D/F/files
+// A/D/G/files
+// A/D/H/
+// A/H/ - included in results
+// A/H/I/files
+// A/H/J/files
+TEST_F(MediaScanManagerTest, MergeRedundant) {
+  base::FilePath path;
+  MediaFolderFinder::MediaFolderFinderResults found_folders;
+  std::vector<base::FilePath> sensitive_locations;
+  std::vector<base::FilePath> expected_folders;
+  MediaGalleryScanResult file_counts;
+  file_counts.audio_count = 1;
+  file_counts.image_count = 2;
+  file_counts.video_count = 3;
+  MakeTestFolder("A", &path);
+  MakeTestFolder("A/B", &path);
+  MakeTestFolder("A/B/C", &path);
+  found_folders[path] = file_counts;
+  // Not dense enough.
+  MakeTestFolder("A/D", &path);
+  MakeTestFolder("A/D/E", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/F", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/G", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/H", &path);
+  // Dense enough to be reported.
+  MakeTestFolder("A/H", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/H/I", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/H/J", &path);
+  found_folders[path] = file_counts;
+  MediaFolderFinder::MediaFolderFinderResults results =
+      FindContainerScanResults(found_folders, sensitive_locations);
+  EXPECT_EQ(expected_folders.size(), results.size());
+  for (std::vector<base::FilePath>::const_iterator it =
+           expected_folders.begin();
+       it != expected_folders.end();
+       ++it) {
+    EXPECT_TRUE(results.find(*it) != results.end());
+  }
+}
+
+// Make sure intermediates are not included.
+//
+// A/ - included in results
+// A/B1/ - NOT included
+// A/B1/B2/files
+// A/C1/ - NOT included
+// A/C1/C2/files
+TEST_F(MediaScanManagerTest, MergeRedundantNoIntermediates) {
+  base::FilePath path;
+  MediaFolderFinder::MediaFolderFinderResults found_folders;
+  std::vector<base::FilePath> sensitive_locations;
+  std::vector<base::FilePath> expected_folders;
+  MediaGalleryScanResult file_counts;
+  file_counts.audio_count = 1;
+  file_counts.image_count = 2;
+  file_counts.video_count = 3;
+  MakeTestFolder("A", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/B1", &path);
+  MakeTestFolder("A/B1/B2", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/C1", &path);
+  MakeTestFolder("A/C1/C2", &path);
+  found_folders[path] = file_counts;
+  // Make "home dir" not dense enough.
+  MakeTestFolder("D", &path);
+  MediaFolderFinder::MediaFolderFinderResults results =
+      FindContainerScanResults(found_folders, sensitive_locations);
+  EXPECT_EQ(expected_folders.size(), results.size());
+  for (std::vector<base::FilePath>::const_iterator it =
+           expected_folders.begin();
+       it != expected_folders.end();
+       ++it) {
+    EXPECT_TRUE(results.find(*it) != results.end());
+  }
+}
+
+// Make sure "A/" only gets a count of 1, from "A/D/",
+// not 2 from "A/D/H/" and "A/D/I/".
+//
+// A/ - NOT included
+// A/D/ - included in results
+// A/D/E/files
+// A/D/F/files
+// A/D/G/files
+// A/D/H/files
+// A/D/I/ - NOT included
+// A/D/I/J/files
+TEST_F(MediaScanManagerTest, MergeRedundantVerifyNoOvercount) {
+  base::FilePath path;
+  MediaFolderFinder::MediaFolderFinderResults found_folders;
+  std::vector<base::FilePath> sensitive_locations;
+  std::vector<base::FilePath> expected_folders;
+  MediaGalleryScanResult file_counts;
+  file_counts.audio_count = 1;
+  file_counts.image_count = 2;
+  file_counts.video_count = 3;
+  MakeTestFolder("A", &path);
+  MakeTestFolder("A/D", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/D/E", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/F", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/G", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/H", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/I", &path);
+  MakeTestFolder("A/D/I/J", &path);
+  found_folders[path] = file_counts;
+  MediaFolderFinder::MediaFolderFinderResults results =
+      FindContainerScanResults(found_folders, sensitive_locations);
+  EXPECT_EQ(expected_folders.size(), results.size());
+  for (std::vector<base::FilePath>::const_iterator it =
+           expected_folders.begin();
+       it != expected_folders.end();
+       ++it) {
+    EXPECT_TRUE(results.find(*it) != results.end());
+  }
+}
+
+// Make sure that sensistive directories are pruned.
+//
+// A/ - NOT included
+// A/B/ - sensitive
+// A/C/ - included in results
+// A/C/G/files
+// A/C/H/files
+// A/D/ - included in results
+// A/D/I/files
+// A/D/J/files
+// A/E/ - included in results
+// A/E/K/files
+// A/E/L/files
+// A/F/ - included in results
+// A/F/M/files
+// A/F/N/files
+TEST_F(MediaScanManagerTest, MergeRedundantWithSensitive) {
+  base::FilePath path;
+  MediaFolderFinder::MediaFolderFinderResults found_folders;
+  std::vector<base::FilePath> sensitive_locations;
+  std::vector<base::FilePath> expected_folders;
+  MediaGalleryScanResult file_counts;
+  file_counts.audio_count = 1;
+  file_counts.image_count = 2;
+  file_counts.video_count = 3;
+  MakeTestFolder("A", &path);
+  MakeTestFolder("A/B", &path);
+  sensitive_locations.push_back(path);
+  MakeTestFolder("A/C", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/C/G", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/C/H", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/D/I", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/D/J", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/E", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/E/K", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/E/L", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/F", &path);
+  expected_folders.push_back(path);
+  MakeTestFolder("A/F/M", &path);
+  found_folders[path] = file_counts;
+  MakeTestFolder("A/F/N", &path);
+  found_folders[path] = file_counts;
+  MediaFolderFinder::MediaFolderFinderResults results =
+      FindContainerScanResults(found_folders, sensitive_locations);
+  EXPECT_EQ(expected_folders.size(), results.size());
+  for (std::vector<base::FilePath>::const_iterator it =
+           expected_folders.begin();
+       it != expected_folders.end();
+       ++it) {
+    EXPECT_TRUE(results.find(*it) != results.end());
+  }
+}
+
 TEST_F(MediaScanManagerTest, Containers) {
   MediaGalleryScanResult file_counts;
   file_counts.audio_count = 1;
   base::FilePath path;
   std::set<base::FilePath> expected_galleries;
   std::set<base::FilePath> bad_galleries;
   MediaFolderFinder::MediaFolderFinderResults found_folders;
   size_t galleries_before = gallery_count();
 
   // Should manifest as a gallery in result1.
@@ skipping 96 matching lines @@
   file_counts.image_count = 0;
   file_counts.video_count = 7;
   base::FilePath path;
   MakeTestFolder("uscan", &path);
   found_folders[path] = file_counts;
 
   file_counts.video_count = 11;
   MakeTestFolder("gscan/dir1", &path);
   found_folders[path] = file_counts;
 
+  MakeTestFolder("junk", &path);
+
   SetFindFoldersResults(true, found_folders);
   file_counts.video_count = 7;
   SetExpectedScanResults(1 /*gallery_count*/, file_counts);
   StartScan();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, FindFolderDestroyCount());
   EXPECT_EQ(galleries_before + 2, gallery_count());
   CheckFileCounts(granted_scan, 0, 0, 11);
   // The new scan result should be one more than it's previous id.
@@ skipping 20 matching lines @@
   MediaGalleryScanResult file_counts;
   file_counts.audio_count = 4;
   base::FilePath path;
   MakeTestFolder("auto/dir1", &path);
   found_folders[path] = file_counts;
 
   file_counts.audio_count = 6;
   MakeTestFolder("scan", &path);
   found_folders[path] = file_counts;
 
+  MakeTestFolder("junk", &path);
+
   file_counts.audio_count = 5;
   MakeTestFolder("user/dir2", &path);
   found_folders[path] = file_counts;
 
   SetFindFoldersResults(true, found_folders);
 
   file_counts.audio_count = 0;
   SetExpectedScanResults(0 /*gallery_count*/, file_counts);
   StartScan();
 
@@ skipping 40 matching lines @@
   file_counts.audio_count *= kGalleriesAdded;
   file_counts.image_count *= kGalleriesAdded;
   file_counts.video_count *= kGalleriesAdded;
   SetExpectedScanResults(kGalleriesAdded, file_counts);
   StartScan();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, FindFolderDestroyCount());
   EXPECT_EQ(galleries_before + kGalleriesAdded, gallery_count());
 }