Media Galleries: Prune uninteresting folders when scanning.

chrome/browser/media_galleries/media_scan_manager.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 "chrome/browser/media_galleries/media_scan_manager.h"
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 194 matching lines @@
                             gallery.last_attach_time, file_counts.audio_count,
                             file_counts.image_count, file_counts.video_count);
   }
 }
 
 // A single directory may contain many folders with media in them, without
 // containing any media itself. In fact, the primary purpose of that directory
 // may be to contain media directories. This function tries to find those
 // immediate container directories.
 MediaFolderFinder::MediaFolderFinderResults FindContainerScanResults(
-    const MediaFolderFinder::MediaFolderFinderResults& found_folders) {
+    const MediaFolderFinder::MediaFolderFinderResults& found_folders,
+    const std::vector<base::FilePath>& sensitive_locations) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  std::vector<base::FilePath> abs_sensitive_locations;
+  for (size_t i = 0; i < sensitive_locations.size(); ++i) {
+    base::FilePath path = base::MakeAbsoluteFilePath(sensitive_locations[i]);
+    if (!path.empty())
+      abs_sensitive_locations.push_back(path);
+  }
   // Count the number of scan results with the same parent directory.
   typedef std::map<base::FilePath, int /*count*/> ContainerCandidates;
   ContainerCandidates candidates;
   for (MediaFolderFinder::MediaFolderFinderResults::const_iterator it =
            found_folders.begin(); it != found_folders.end(); ++it) {
     base::FilePath parent_directory = it->first.DirName();
+
+    // Skip sensitive folders and their ancestors.
+    bool is_sensitive = false;
+    base::FilePath abs_parent_directory =
+        base::MakeAbsoluteFilePath(parent_directory);
+    if (abs_parent_directory.empty())
+      continue;
+    for (size_t i = 0; i < abs_sensitive_locations.size(); ++i) {
+      if (abs_parent_directory == abs_sensitive_locations[i] ||
+          abs_parent_directory.IsParent(abs_sensitive_locations[i])) {
+        is_sensitive = true;
+        continue;
+      }
+    }
+    if (is_sensitive)
+      continue;
+
     ContainerCandidates::iterator existing = candidates.find(parent_directory);
     if (existing == candidates.end()) {
       candidates[parent_directory] = 1;
     } else {
       existing->second++;
     }
   }
 
   // If a parent directory has more than one scan result, consider it.
   MediaFolderFinder::MediaFolderFinderResults result;
@@ skipping 12 matching lines @@
          name = dir_counter.Next()) {
       if (!base::IsLink(name))
         count++;
     }
     if (it->second * 100 / count >= kContainerDirectoryMinimumPercent)
       result[it->first] = MediaGalleryScanResult();
   }
   return result;
 }
 
-void RemoveSensitiveLocations(
-    MediaFolderFinder::MediaFolderFinderResults* found_folders) {
-  // TODO(vandebo) Use the greylist from filesystem api.
-}
-
 int CountScanResultsForExtension(MediaGalleriesPreferences* preferences,
                                  const extensions::Extension* extension,
                                  MediaGalleryScanResult* file_counts) {
   int gallery_count = 0;
 
   MediaGalleryPrefIdSet permitted_galleries =
       preferences->GalleriesForExtension(*extension);
   const MediaGalleriesPrefInfoMap& known_galleries =
       preferences->known_galleries();
   for (MediaGalleriesPrefInfoMap::const_iterator it = known_galleries.begin();
@@ skipping 167 matching lines @@
     bool success,
     const MediaFolderFinder::MediaFolderFinderResults& found_folders) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!folder_finder_ || !success) {
     folder_finder_.reset();
     return;
   }
 
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(FindContainerScanResults, found_folders),
+      base::Bind(FindContainerScanResults,
+                 found_folders,
+                 folder_finder_->graylisted_folders()),
       base::Bind(&MediaScanManager::OnFoundContainerDirectories,
-                 weak_factory_.GetWeakPtr(), found_folders));
+                 weak_factory_.GetWeakPtr(),
+                 found_folders));
 }
 
 void MediaScanManager::OnFoundContainerDirectories(
     const MediaFolderFinder::MediaFolderFinderResults& found_folders,
     const MediaFolderFinder::MediaFolderFinderResults& container_folders) {
   MediaFolderFinder::MediaFolderFinderResults folders;
   folders.insert(found_folders.begin(), found_folders.end());
   folders.insert(container_folders.begin(), container_folders.end());
 
-  RemoveSensitiveLocations(&folders);
-
   for (ScanObserverMap::iterator scans_for_profile = observers_.begin();
        scans_for_profile != observers_.end();
        ++scans_for_profile) {
     if (scans_for_profile->second.scanning_extensions.empty())
       continue;
     Profile* profile = scans_for_profile->first;
     MediaGalleriesPreferences* preferences =
         MediaGalleriesPreferencesFactory::GetForProfile(profile);
     ExtensionService* extension_service =
         extensions::ExtensionSystem::Get(profile)->extension_service();
@@ skipping 18 matching lines @@
                                                            gallery_count,
                                                            file_counts);
       }
     }
     scanning_extensions->clear();
     preferences->SetLastScanCompletionTime(base::Time::Now());
   }
   registrar_.RemoveAll();
   folder_finder_.reset();
 }