Have FindContainerScanResults() find broader media container directories

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/metrics/histogram.h"
@@ skipping 192 matching lines @@
                             MediaGalleryPrefInfo::kScanResult,
                             gallery.volume_label, gallery.vendor_name,
                             gallery.model_name, gallery.total_size_in_bytes,
                             gallery.last_attach_time, file_counts.audio_count,
                             file_counts.image_count, file_counts.video_count);
   }
   UMA_HISTOGRAM_COUNTS_10000("MediaGalleries.ScanGalleriesPopulated",
                              unique_found_folders.size() + to_update.size());
 }
 
-// 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 std::vector<base::FilePath>& sensitive_locations) {
-  DCHECK_CURRENTLY_ON(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;
-  for (ContainerCandidates::const_iterator it = candidates.begin();
-       it != candidates.end();
-       ++it) {
-    if (it->second <= 1)
-      continue;
-
-    base::FileEnumerator dir_counter(it->first, false /*recursive*/,
-                                     base::FileEnumerator::DIRECTORIES);
-    base::FileEnumerator::FileInfo info;
-    int count = 0;
-    for (base::FilePath name = dir_counter.Next();
-         !name.empty();
-         name = dir_counter.Next()) {
-      if (!base::IsLink(name))
-        count++;
-    }
-    if (it->second * 100 / count >= kContainerDirectoryMinimumPercent)
-      result[it->first] = MediaGalleryScanResult();
-  }
-  return result;
-}
-
 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();
        it != known_galleries.end();
        ++it) {
     if (it->second.type == MediaGalleryPrefInfo::kScanResult &&
         !ContainsKey(permitted_galleries, it->first)) {
       gallery_count++;
       file_counts->audio_count += it->second.audio_count;
       file_counts->image_count += it->second.image_count;
       file_counts->video_count += it->second.video_count;
     }
   }
   return gallery_count;
 }
 
+int CountDirectoryEntries(const base::FilePath& path) {
+  base::FileEnumerator dir_counter(path, false /*recursive*/,
+                                   base::FileEnumerator::DIRECTORIES);
+  int count = 0;
+  base::FileEnumerator::FileInfo info;
+  for (base::FilePath name = dir_counter.Next();
+       !name.empty();
+       name = dir_counter.Next()) {
+    if (!base::IsLink(name))
+      ++count;
+  }
+  return count;
+}
+
+struct ContainerCount {
+  int seen_count, entries_count;
+  bool is_qualified;
+
+  ContainerCount() : seen_count(0), entries_count(-1), is_qualified(false) {}
+};
+
+typedef std::map<base::FilePath, ContainerCount> ContainerCandidates;
+
 }  // namespace
 
 MediaScanManager::MediaScanManager()
     : scoped_extension_registry_observer_(this),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 MediaScanManager::~MediaScanManager() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 101 matching lines @@
                              base::Time::Now() - scan_start_time_);
     scan_start_time_ = base::Time();
   }
 }
 
 void MediaScanManager::SetMediaFolderFinderFactory(
     const MediaFolderFinderFactory& factory) {
   testing_folder_finder_factory_ = factory;
 }
 
+// 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
+// container directories.
+MediaFolderFinder::MediaFolderFinderResults
+MediaScanManager::FindContainerScanResults(
+    const MediaFolderFinder::MediaFolderFinderResults& found_folders,
+    const std::vector<base::FilePath>& sensitive_locations) {
+  DCHECK_CURRENTLY_ON(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);
+  }
+  // Recursively find parent directories with majority of media directories,
+  // or container directories.
+  // |candidates| keeps track of directories which might have enough
+  // such directories to have us return them.
+  typedef std::map<base::FilePath, ContainerCount> ContainerCandidates;
+  ContainerCandidates candidates;
+  for (MediaFolderFinder::MediaFolderFinderResults::const_iterator it =
+           found_folders.begin(); it != found_folders.end(); ++it) {
+    base::FilePath child_directory = it->first;
+    base::FilePath parent_directory = child_directory.DirName();
+
+    // Parent of root is root.
+    while (!parent_directory.empty() && child_directory != parent_directory) {
+      // Skip sensitive folders and their ancestors.
+      base::FilePath abs_parent_directory =
+          base::MakeAbsoluteFilePath(parent_directory);
+      if (abs_parent_directory.empty())
+        break;
+      bool is_sensitive = false;
+      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;
+          break;
+        }
+      }
+      if (is_sensitive)
+        break;
+
+      // Don't bother with ones we already have.
+      if (found_folders.find(parent_directory) != found_folders.end())
+        continue;
+
+      ContainerCandidates::iterator parent_it =
+          candidates.find(parent_directory);
+      if (parent_it == candidates.end()) {
+        ContainerCount count;
+        count.seen_count = 1;
+        count.entries_count = CountDirectoryEntries(parent_directory);
+        parent_it = candidates.insert(std::make_pair(parent_directory,
+                                                     count)).first;
+      } else {
+        ++candidates[parent_directory].seen_count;
+      }
+      // If already sufficient, bail.
+      if (parent_it->second.is_qualified)
+        break;
+      // If now sufficient, mark qualified and check parent.
+      if (parent_it->second.seen_count * 100 / parent_it->second.entries_count
+          >= kContainerDirectoryMinimumPercent) {
+        parent_it->second.is_qualified = true;
+      } else {
+        break;

[vandebo (ex-Chrome), 2014/06/03 18:08:31]

nit: This else break construct is kind of hard to read / ugly. I was hoping
you'd take care of it with the early exit. Can you make the early exit:

if (parent_it->second.is_qualified || parent_it->second.seen_count * 100 /
parent_it->second.entries_count < kContainerDirectoryMinimumPercent) {
  break;
}

Then line 445 joins up with line 449,450.

[Kevin Bailey, 2014/06/03 18:31:25]

Couldn't make it *exactly* the same due to line length. Hope it's ok.

[vandebo (ex-Chrome), 2014/06/03 18:42:31]

Assumed... as is, it violated style guide. I'd suggest:
      if (parent_it->second.is_qualified || 
          parent_it->second.seen_count * 100 / parent_it->second.entries_count <
             kContainerDirectoryMinimumPercent) {

You can also see what git cl format suggests.

+      }
+      child_directory = parent_directory;
+      parent_directory = child_directory.DirName();
+    }
+  }
+  MediaFolderFinder::MediaFolderFinderResults result;
+  // Copy and return worthy results.
+  for (ContainerCandidates::const_iterator it = candidates.begin();
+       it != candidates.end(); ++it) {
+    if (it->second.is_qualified && it->second.seen_count >= 2)
+      result[it->first] = MediaGalleryScanResult();
+  }
+  return result;
+}
+
 MediaScanManager::ScanObservers::ScanObservers() : observer(NULL) {}
 MediaScanManager::ScanObservers::~ScanObservers() {}
 
 void MediaScanManager::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   CancelScan(Profile::FromBrowserContext(browser_context), extension);
 }
@@ skipping 72 matching lines @@
                                                            gallery_count,
                                                            file_counts);
       }
     }
     scanning_extensions->clear();
     preferences->SetLastScanCompletionTime(base::Time::Now());
   }
   scoped_extension_registry_observer_.RemoveAll();
   folder_finder_.reset();
 }