Media galleries preferences also needs to track file counts for scan results.

chrome/browser/media_galleries/media_galleries_preferences_unittest.cc

 // Copyright (c) 2012 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.
 
 // MediaGalleriesPreferences unit tests.
 
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
@@ skipping 174 matching lines @@
   void VerifyGalleryInfo(const MediaGalleryPrefInfo& actual,
                          MediaGalleryPrefId expected_id) const {
     MediaGalleriesPrefInfoMap::const_iterator in_expectation =
       expected_galleries_.find(expected_id);
     ASSERT_FALSE(in_expectation == expected_galleries_.end())  << expected_id;
     EXPECT_EQ(in_expectation->second.pref_id, actual.pref_id);
     EXPECT_EQ(in_expectation->second.display_name, actual.display_name);
     EXPECT_EQ(in_expectation->second.device_id, actual.device_id);
     EXPECT_EQ(in_expectation->second.path.value(), actual.path.value());
     EXPECT_EQ(in_expectation->second.type, actual.type);
+    EXPECT_EQ(in_expectation->second.image_count, actual.image_count);
+    EXPECT_EQ(in_expectation->second.music_count, actual.music_count);
+    EXPECT_EQ(in_expectation->second.video_count, actual.video_count);
   }
 
   MediaGalleriesPreferences* gallery_prefs() {
     return gallery_prefs_.get();
   }
 
   uint64 default_galleries_count() {
     return default_galleries_count_;
   }
 
   void AddGalleryExpectation(MediaGalleryPrefId id, base::string16 display_name,
                              std::string device_id,
                              base::FilePath relative_path,
                              MediaGalleryPrefInfo::Type type) {
     expected_galleries_[id].pref_id = id;
     expected_galleries_[id].display_name = display_name;
     expected_galleries_[id].device_id = device_id;
     expected_galleries_[id].path = relative_path.NormalizePathSeparators();
     expected_galleries_[id].type = type;
 
     if (type == MediaGalleryPrefInfo::kAutoDetected)
       expected_galleries_for_all.insert(id);
 
     expected_device_map[device_id].insert(id);
   }
 
+  void AddScanResultExpectation(MediaGalleryPrefId id,
+                                base::string16 display_name,
+                                std::string device_id,
+                                base::FilePath relative_path,
+                                int image_count,
+                                int music_count,
+                                int video_count) {
+    AddGalleryExpectation(id, display_name, device_id, relative_path,
+                          MediaGalleryPrefInfo::kScanResult);
+    expected_galleries_[id].image_count = image_count;
+    expected_galleries_[id].music_count = music_count;
+    expected_galleries_[id].video_count = video_count;
+  }
+
   MediaGalleryPrefId AddGalleryWithNameV0(const std::string& device_id,
                                           const base::string16& display_name,
                                           const base::FilePath& relative_path,
                                           bool user_added) {
     MediaGalleryPrefInfo::Type type =
         user_added ? MediaGalleryPrefInfo::kUserAdded
                    : MediaGalleryPrefInfo::kAutoDetected;
     return gallery_prefs()->AddGalleryInternal(
         device_id, display_name, relative_path, type,
         base::string16(), base::string16(), base::string16(), 0, base::Time(),
-        false, 0);
+        false, 0, 0, 0, 0);
   }
 
   MediaGalleryPrefId AddGalleryWithNameV1(const std::string& device_id,
                                           const base::string16& display_name,
                                           const base::FilePath& relative_path,
                                           bool user_added) {
     MediaGalleryPrefInfo::Type type =
         user_added ? MediaGalleryPrefInfo::kUserAdded
                    : MediaGalleryPrefInfo::kAutoDetected;
     return gallery_prefs()->AddGalleryInternal(
         device_id, display_name, relative_path, type,
         base::string16(), base::string16(), base::string16(), 0, base::Time(),
-        false, 1);
+        false, 0, 0, 0, 1);
   }
 
   MediaGalleryPrefId AddGalleryWithNameV2(const std::string& device_id,
                                           const base::string16& display_name,
                                           const base::FilePath& relative_path,
                                           MediaGalleryPrefInfo::Type type) {
     return gallery_prefs()->AddGalleryInternal(
         device_id, display_name, relative_path, type,
         base::string16(), base::string16(), base::string16(), 0, base::Time(),
-        false, 2);
+        false, 0, 0, 0, 2);
   }
 
   bool UpdateDeviceIDForSingletonType(const std::string& device_id) {
     return gallery_prefs()->UpdateDeviceIDForSingletonType(device_id);
   }
 
   scoped_refptr<extensions::Extension> all_permission_extension;
   scoped_refptr<extensions::Extension> regular_permission_extension;
   scoped_refptr<extensions::Extension> no_permissions_extension;
 
@@ skipping 178 matching lines @@
   Verify();
 
   // Add a new auto detected gallery.
   path = MakePath("new_auto");
   MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
   id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
                                    MediaGalleryPrefInfo::kAutoDetected,
                                    ASCIIToUTF16("volume label"),
                                    ASCIIToUTF16("vendor name"),
                                    ASCIIToUTF16("model name"),
-                                   1000000ULL, now);
+                                   1000000ULL, now, 0, 0, 0);
   EXPECT_EQ(default_galleries_count() + 1UL, id);
   AddGalleryExpectation(id, base::string16(), info.device_id(), relative_path,
                         MediaGalleryPrefInfo::kAutoDetected);
   Verify();
 
   MediaGalleryPrefInfo gallery_info;
   EXPECT_TRUE(gallery_prefs()->LookUpGalleryByPath(MakePath("new_auto"),
                                                    &gallery_info));
   EXPECT_TRUE(gallery_info.volume_metadata_valid);
   EXPECT_EQ(ASCIIToUTF16("volume label"), gallery_info.volume_label);
@@ skipping 25 matching lines @@
   AddGalleryExpectation(id, info.name(), info.device_id(), relative_path,
                         MediaGalleryPrefInfo::kAutoDetected);
   Verify();
 
   metadata_id = gallery_prefs()->AddGallery(info.device_id(),
                                             relative_path,
                                             MediaGalleryPrefInfo::kAutoDetected,
                                             ASCIIToUTF16("volume label"),
                                             ASCIIToUTF16("vendor name"),
                                             ASCIIToUTF16("model name"),
-                                            1000000ULL, now);
+                                            1000000ULL, now, 0, 0, 0);
   EXPECT_EQ(id, metadata_id);
   AddGalleryExpectation(id, base::string16(), info.device_id(), relative_path,
                         MediaGalleryPrefInfo::kAutoDetected);
 
   // Make sure the display_name is set to empty now, as the metadata
   // upgrade should set the manual override name empty.
   Verify();
 }
 
 // Whenever an "AutoDetected" gallery is removed, it is moved to a black listed
@@ skipping 485 matching lines @@
   expected_device_map[updated_device_id].insert(id);
   Verify();
   EXPECT_EQ(1, observer.notifications());
 
   // No gallery for type.
   std::string new_device_id =
       StorageInfo::MakeDeviceId(StorageInfo::PICASA, path.AsUTF8Unsafe());
   EXPECT_FALSE(UpdateDeviceIDForSingletonType(new_device_id));
 }
 
+TEST_F(MediaGalleriesPreferencesTest, ScanResults) {
+  MediaGalleryPrefId id;
+  base::FilePath path;
+  StorageInfo info;
+  base::FilePath relative_path;
+  base::Time now = base::Time::Now();
+  Verify();
+
+  // Add a new scan result gallery to test with.
+  path = MakePath("new_scan");
+  MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path);
+  id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
+                                   MediaGalleryPrefInfo::kScanResult,
+                                   ASCIIToUTF16("volume label"),
+                                   ASCIIToUTF16("vendor name"),
+                                   ASCIIToUTF16("model name"),
+                                   1000000ULL, now, 1, 2, 3);
+  EXPECT_EQ(default_galleries_count() + 1UL, id);
+  AddScanResultExpectation(id, base::string16(), info.device_id(),
+                           relative_path, 1, 2, 3);
+  Verify();
+
+  // Update the found media count.
+  id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
+                                   MediaGalleryPrefInfo::kScanResult,
+                                   ASCIIToUTF16("volume label"),
+                                   ASCIIToUTF16("vendor name"),
+                                   ASCIIToUTF16("model name"),
+                                   1000000ULL, now, 4, 5, 6);
+  EXPECT_EQ(default_galleries_count() + 1UL, id);
+  AddScanResultExpectation(id, base::string16(), info.device_id(),
+                           relative_path, 4, 5, 6);
+  Verify();
+
+  // Remove a scan result (i.e. make it blacklisted).
+  gallery_prefs()->ForgetGalleryById(id);
+  expected_galleries_[id].type = MediaGalleryPrefInfo::kRemovedScan;
+  expected_galleries_[id].image_count = 0;
+  expected_galleries_[id].music_count = 0;
+  expected_galleries_[id].video_count = 0;
+  Verify();
+
+  // Try adding the gallery again as a scan result it should be a no-op.
+  id = gallery_prefs()->AddGallery(info.device_id(), relative_path,
+                                   MediaGalleryPrefInfo::kScanResult,
+                                   ASCIIToUTF16("volume label"),
+                                   ASCIIToUTF16("vendor name"),
+                                   ASCIIToUTF16("model name"),
+                                   1000000ULL, now, 7, 8, 9);
+  EXPECT_EQ(default_galleries_count() + 1UL, id);
+  Verify();
+
+  // Add the gallery again as a user action.
+  id = gallery_prefs()->AddGalleryByPath(path,
+                                         MediaGalleryPrefInfo::kUserAdded);
+  EXPECT_EQ(default_galleries_count() + 1UL, id);
+  AddGalleryExpectation(id, base::string16(), info.device_id(), relative_path,
+                        MediaGalleryPrefInfo::kUserAdded);
+  Verify();
+}
+
 TEST(MediaGalleriesPrefInfoTest, NameGeneration) {
   ASSERT_TRUE(TestStorageMonitor::CreateAndInstall());
 
   MediaGalleryPrefInfo info;
   info.pref_id = 1;
   info.display_name = ASCIIToUTF16("override");
   info.device_id = StorageInfo::MakeDeviceId(
       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, "unique");
 
   EXPECT_EQ(ASCIIToUTF16("override"), info.GetGalleryDisplayName());
@@ skipping 23 matching lines @@
   info.volume_label = base::string16();
   EXPECT_EQ(ASCIIToUTF16("vendor, model"), info.GetGalleryDisplayName());
 
   info.device_id = StorageInfo::MakeDeviceId(
       StorageInfo::FIXED_MASS_STORAGE, "unique");
   EXPECT_EQ(base::FilePath(FILE_PATH_LITERAL("unique")).AsUTF8Unsafe(),
             base::UTF16ToUTF8(info.GetGalleryTooltip()));
 
   TestStorageMonitor::RemoveSingleton();
 }