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

chrome/browser/media_galleries/media_galleries_preferences.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.
 
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
 
 #include "base/base_paths_posix.h"
 #include "base/callback.h"
 #include "base/i18n/time_formatting.h"
 #include "base/path_service.h"
@@ skipping 44 matching lines @@
 const char kMediaGalleriesDeviceIdKey[] = "deviceId";
 const char kMediaGalleriesDisplayNameKey[] = "displayName";
 const char kMediaGalleriesPathKey[] = "path";
 const char kMediaGalleriesPrefIdKey[] = "prefId";
 const char kMediaGalleriesTypeKey[] = "type";
 const char kMediaGalleriesVolumeLabelKey[] = "volumeLabel";
 const char kMediaGalleriesVendorNameKey[] = "vendorName";
 const char kMediaGalleriesModelNameKey[] = "modelName";
 const char kMediaGalleriesSizeKey[] = "totalSize";
 const char kMediaGalleriesLastAttachTimeKey[] = "lastAttachTime";
+const char kMediaGalleriesScanImageCountKey[] = "imageCount";
+const char kMediaGalleriesScanMusicCountKey[] = "musicCount";
+const char kMediaGalleriesScanVideoCountKey[] = "videoCount";
 const char kMediaGalleriesPrefsVersionKey[] = "preferencesVersion";
 
 const char kMediaGalleriesTypeAutoDetectedValue[] = "autoDetected";
 const char kMediaGalleriesTypeBlackListedValue[] = "blackListed";
 const char kMediaGalleriesTypeRemovedScanValue[] = "removedScan";
 const char kMediaGalleriesTypeScanResultValue[] = "scanResult";
 const char kMediaGalleriesTypeUserAddedValue[] = "userAdded";
 
 const char kIPhotoGalleryName[] = "iPhoto";
 const char kITunesGalleryName[] = "iTunes";
 const char kPicasaGalleryName[] = "Picasa";
 
+const int kCurrentPrefsVersion = 2;
+
 int NumberExtensionsUsingMediaGalleries(Profile* profile) {
   int count = 0;
   if (!profile)
     return count;
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!extension_service)
     return count;
 
   const extensions::ExtensionSet* extensions = extension_service->extensions();
@@ skipping 80 matching lines @@
   base::string16 display_name;
   std::string device_id;
   base::FilePath::StringType path;
   MediaGalleryPrefInfo::Type type = MediaGalleryPrefInfo::kInvalidType;
   base::string16 volume_label;
   base::string16 vendor_name;
   base::string16 model_name;
   double total_size_in_bytes = 0.0;
   double last_attach_time = 0.0;
   bool volume_metadata_valid = false;
+  int image_count = 0;
+  int music_count = 0;
+  int video_count = 0;
   int prefs_version = 0;
 
   if (!GetPrefId(dict, &pref_id) ||
       !dict.GetString(kMediaGalleriesDeviceIdKey, &device_id) ||
       !dict.GetString(kMediaGalleriesPathKey, &path) ||
       !GetType(dict, &type)) {
     return false;
   }
 
   dict.GetString(kMediaGalleriesDisplayNameKey, &display_name);
   dict.GetInteger(kMediaGalleriesPrefsVersionKey, &prefs_version);
 
   if (dict.GetString(kMediaGalleriesVolumeLabelKey, &volume_label) &&
       dict.GetString(kMediaGalleriesVendorNameKey, &vendor_name) &&
       dict.GetString(kMediaGalleriesModelNameKey, &model_name) &&
       dict.GetDouble(kMediaGalleriesSizeKey, &total_size_in_bytes) &&
       dict.GetDouble(kMediaGalleriesLastAttachTimeKey, &last_attach_time)) {
     volume_metadata_valid = true;
   }
 
+  if (type == MediaGalleryPrefInfo::kScanResult &&
+      dict.GetInteger(kMediaGalleriesScanImageCountKey, &image_count) &&
+      dict.GetInteger(kMediaGalleriesScanMusicCountKey, &music_count) &&
+      dict.GetInteger(kMediaGalleriesScanVideoCountKey, &video_count)) {
+    out_gallery_info->image_count = image_count;
+    out_gallery_info->music_count = music_count;
+    out_gallery_info->video_count = video_count;
+  }
+
   out_gallery_info->pref_id = pref_id;
   out_gallery_info->display_name = display_name;
   out_gallery_info->device_id = device_id;
   out_gallery_info->path = base::FilePath(path);
   out_gallery_info->type = type;
   out_gallery_info->volume_label = volume_label;
   out_gallery_info->vendor_name = vendor_name;
   out_gallery_info->model_name = model_name;
   out_gallery_info->total_size_in_bytes = total_size_in_bytes;
   out_gallery_info->last_attach_time =
       base::Time::FromInternalValue(last_attach_time);
   out_gallery_info->volume_metadata_valid = volume_metadata_valid;
   out_gallery_info->prefs_version = prefs_version;
 
   return true;
 }
 
 base::DictionaryValue* CreateGalleryPrefInfoDictionary(
     const MediaGalleryPrefInfo& gallery) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString(kMediaGalleriesPrefIdKey,
                   base::Uint64ToString(gallery.pref_id));
-  if (!gallery.volume_metadata_valid)
-    dict->SetString(kMediaGalleriesDisplayNameKey, gallery.display_name);
   dict->SetString(kMediaGalleriesDeviceIdKey, gallery.device_id);
   dict->SetString(kMediaGalleriesPathKey, gallery.path.value());
   dict->SetString(kMediaGalleriesTypeKey, TypeToStringValue(gallery.type));
 
   if (gallery.volume_metadata_valid) {
     dict->SetString(kMediaGalleriesVolumeLabelKey, gallery.volume_label);
     dict->SetString(kMediaGalleriesVendorNameKey, gallery.vendor_name);
     dict->SetString(kMediaGalleriesModelNameKey, gallery.model_name);
     dict->SetDouble(kMediaGalleriesSizeKey, gallery.total_size_in_bytes);
     dict->SetDouble(kMediaGalleriesLastAttachTimeKey,
                     gallery.last_attach_time.ToInternalValue());
+  } else {
+    dict->SetString(kMediaGalleriesDisplayNameKey, gallery.display_name);
+  }
+
+  if (gallery.type == MediaGalleryPrefInfo::kScanResult) {
+    dict->SetInteger(kMediaGalleriesScanImageCountKey, gallery.image_count);
+    dict->SetInteger(kMediaGalleriesScanMusicCountKey, gallery.music_count);
+    dict->SetInteger(kMediaGalleriesScanVideoCountKey, gallery.video_count);
   }
 
   // Version 0 of the prefs format was that the display_name was always
   // used to show the user-visible name of the gallery. Version 1 means
   // that there is an optional display_name, and when it is present, it
   // overrides the name that would be built from the volume metadata, path,
   // or whatever other data. So if we see a display_name with version 0, it
   // means it may be overwritten simply by getting new volume metadata.
   // A display_name with version 1 should not be overwritten.
   dict->SetInteger(kMediaGalleriesPrefsVersionKey, gallery.prefs_version);
@@ skipping 59 matching lines @@
   return product_name;
 }
 
 }  // namespace
 
 MediaGalleryPrefInfo::MediaGalleryPrefInfo()
     : pref_id(kInvalidMediaGalleryPrefId),
       type(kInvalidType),
       total_size_in_bytes(0),
       volume_metadata_valid(false),
+      image_count(0),
+      music_count(0),
+      video_count(0),
       prefs_version(0) {
 }
 
 MediaGalleryPrefInfo::~MediaGalleryPrefInfo() {}
 
 base::FilePath MediaGalleryPrefInfo::AbsolutePath() const {
   base::FilePath base_path = MediaStorageUtil::FindDevicePathById(device_id);
   DCHECK(!path.IsAbsolute());
   return base_path.empty() ? base_path : base_path.Append(path);
 }
@@ skipping 162 matching lines @@
     if (!(StorageInfo::IsMediaDevice(existing_devices[i].device_id()) &&
           StorageInfo::IsRemovableDevice(existing_devices[i].device_id())))
       continue;
     AddGallery(existing_devices[i].device_id(),
                base::FilePath(),
                MediaGalleryPrefInfo::kAutoDetected,
                existing_devices[i].storage_label(),
                existing_devices[i].vendor_name(),
                existing_devices[i].model_name(),
                existing_devices[i].total_size_in_bytes(),
-               base::Time::Now());
+               base::Time::Now(), 0, 0, 0);
   }
 
   for (std::vector<base::Closure>::iterator iter =
            on_initialize_callbacks_.begin();
        iter != on_initialize_callbacks_.end();
        ++iter) {
     iter->Run();
   }
   on_initialize_callbacks_.clear();
 }
@@ skipping 10 matching lines @@
     if (!PathService::Get(kDirectoryKeys[i], &path))
       continue;
 
     base::FilePath relative_path;
     StorageInfo info;
     if (MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path)) {
       AddGalleryInternal(info.device_id(), info.name(), relative_path,
                          MediaGalleryPrefInfo::kAutoDetected,
                          info.storage_label(), info.vendor_name(),
                          info.model_name(), info.total_size_in_bytes(),
-                         base::Time(), true, 2);
+                         base::Time(), true, 0, 0, 0, kCurrentPrefsVersion);
     }
   }
 }
 
 bool MediaGalleriesPreferences::UpdateDeviceIDForSingletonType(
     const std::string& device_id) {
   StorageInfo::Type singleton_type;
   if (!StorageInfo::CrackDeviceId(device_id, &singleton_type, NULL))
     return false;
 
@@ skipping 47 matching lines @@
     else if (StorageInfo::IsITunesDevice(device_id))
       gallery_name = kITunesGalleryName;
     else if (StorageInfo::IsPicasaDevice(device_id))
       gallery_name = kPicasaGalleryName;
     else
       NOTREACHED();
 
     AddGalleryInternal(device_id, base::ASCIIToUTF16(gallery_name),
                        base::FilePath(), MediaGalleryPrefInfo::kAutoDetected,
                        base::string16(), base::string16(), base::string16(), 0,
-                       base::Time(), false, 2);
+                       base::Time(), false, 0, 0, 0, kCurrentPrefsVersion);
   }
 
   OnInitializationCallbackReturned();
 }
 
 void MediaGalleriesPreferences::InitFromPrefs() {
   known_galleries_.clear();
   device_map_.clear();
 
   PrefService* prefs = profile_->GetPrefs();
@@ skipping 30 matching lines @@
 
 void MediaGalleriesPreferences::OnRemovableStorageAttached(
     const StorageInfo& info) {
   DCHECK(IsInitialized());
   if (!StorageInfo::IsMediaDevice(info.device_id()))
     return;
 
   AddGallery(info.device_id(), base::FilePath(),
              MediaGalleryPrefInfo::kAutoDetected, info.storage_label(),
              info.vendor_name(), info.model_name(), info.total_size_in_bytes(),
-             base::Time::Now());
+             base::Time::Now(), 0, 0, 0);
 }
 
 bool MediaGalleriesPreferences::LookUpGalleryByPath(
     const base::FilePath& path,
     MediaGalleryPrefInfo* gallery_info) const {
   DCHECK(IsInitialized());
   StorageInfo info;
   base::FilePath relative_path;
   if (!MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path)) {
     if (gallery_info)
@@ skipping 27 matching lines @@
     gallery_info->pref_id = kInvalidMediaGalleryPrefId;
     gallery_info->device_id = info.device_id();
     gallery_info->path = relative_path;
     gallery_info->type = MediaGalleryPrefInfo::kInvalidType;
     gallery_info->volume_label = info.storage_label();
     gallery_info->vendor_name = info.vendor_name();
     gallery_info->model_name = info.model_name();
     gallery_info->total_size_in_bytes = info.total_size_in_bytes();
     gallery_info->last_attach_time = base::Time::Now();
     gallery_info->volume_metadata_valid = true;
-    gallery_info->prefs_version = 2;
+    gallery_info->prefs_version = kCurrentPrefsVersion;
   }
   return false;
 }
 
 MediaGalleryPrefIdSet MediaGalleriesPreferences::LookUpGalleriesByDeviceId(
     const std::string& device_id) const {
   DeviceIdPrefIdsMap::const_iterator found = device_map_.find(device_id);
   if (found == device_map_.end())
     return MediaGalleryPrefIdSet();
   return found->second;
@@ skipping 17 matching lines @@
 }
 
 MediaGalleryPrefId MediaGalleriesPreferences::AddGallery(
     const std::string& device_id,
     const base::FilePath& relative_path,
     MediaGalleryPrefInfo::Type type,
     const base::string16& volume_label,
     const base::string16& vendor_name,
     const base::string16& model_name,
     uint64 total_size_in_bytes,
-    base::Time last_attach_time) {
+    base::Time last_attach_time,
+    int image_count,
+    int music_count,
+    int video_count) {
   DCHECK(IsInitialized());
   return AddGalleryInternal(device_id, base::string16(), relative_path,
                             type, volume_label, vendor_name, model_name,
-                            total_size_in_bytes, last_attach_time, true, 2);
+                            total_size_in_bytes, last_attach_time, true,
+                            image_count, music_count, video_count,
+                            kCurrentPrefsVersion);
 }
 
 MediaGalleryPrefId MediaGalleriesPreferences::AddGalleryInternal(
     const std::string& device_id, const base::string16& display_name,
     const base::FilePath& relative_path, MediaGalleryPrefInfo::Type type,
     const base::string16& volume_label, const base::string16& vendor_name,
     const base::string16& model_name, uint64 total_size_in_bytes,
-    base::Time last_attach_time,
-    bool volume_metadata_valid,
-    int prefs_version) {
+    base::Time last_attach_time, bool volume_metadata_valid,
+    int image_count, int music_count, int video_count, int prefs_version) {
   DCHECK(type == MediaGalleryPrefInfo::kUserAdded ||
          type == MediaGalleryPrefInfo::kAutoDetected ||
          type == MediaGalleryPrefInfo::kScanResult);
   base::FilePath normalized_relative_path =
       relative_path.NormalizePathSeparators();
   MediaGalleryPrefIdSet galleries_on_device =
     LookUpGalleriesByDeviceId(device_id);
   for (MediaGalleryPrefIdSet::const_iterator pref_id_it =
            galleries_on_device.begin();
        pref_id_it != galleries_on_device.end();
        ++pref_id_it) {
     const MediaGalleryPrefInfo& existing =
         known_galleries_.find(*pref_id_it)->second;
     if (existing.path != normalized_relative_path)
       continue;
 
     bool update_gallery_type = false;
     MediaGalleryPrefInfo::Type new_type = existing.type;
     if (type == MediaGalleryPrefInfo::kUserAdded) {
       if (existing.type == MediaGalleryPrefInfo::kBlackListed) {
         new_type = MediaGalleryPrefInfo::kAutoDetected;
         update_gallery_type = true;
       }
       if (existing.type == MediaGalleryPrefInfo::kRemovedScan) {
-        new_type = type;
+        new_type = MediaGalleryPrefInfo::kUserAdded;
         update_gallery_type = true;
       }
     }
 
     // Status quo: In M27 and M28, galleries added manually use version 0,
     // and galleries added automatically (including default galleries) use
     // version 1. The name override is used by default galleries as well
     // as all device attach events.
     // We want to upgrade the name if the existing version is < 2. Leave it
     // alone if the existing display name is set with version == 2 and the
     // proposed new name is empty.
     bool update_gallery_name = existing.display_name != display_name;
     if (existing.prefs_version == 2 && !existing.display_name.empty() &&
         display_name.empty()) {
       update_gallery_name = false;
     }
     bool update_gallery_metadata = volume_metadata_valid &&
         ((existing.volume_label != volume_label) ||
          (existing.vendor_name != vendor_name) ||
          (existing.model_name != model_name) ||
          (existing.total_size_in_bytes != total_size_in_bytes) ||
          (existing.last_attach_time != last_attach_time));
 
+    bool update_scan_counts =
+      (new_type == MediaGalleryPrefInfo::kScanResult) &&
+      (image_count > 0 || music_count > 0 || video_count > 0);
+
     if (!update_gallery_name && !update_gallery_type &&
-        !update_gallery_metadata)
+        !update_gallery_metadata && !update_scan_counts)
       return *pref_id_it;
 
     PrefService* prefs = profile_->GetPrefs();
     scoped_ptr<ListPrefUpdate> update(
         new ListPrefUpdate(prefs, prefs::kMediaGalleriesRememberedGalleries));
     base::ListValue* list = update->Get();
 
     for (base::ListValue::const_iterator list_iter = list->begin();
          list_iter != list->end();
          ++list_iter) {
       base::DictionaryValue* dict;
       MediaGalleryPrefId iter_id;
       if ((*list_iter)->GetAsDictionary(&dict) &&
           GetPrefId(*dict, &iter_id) &&
           *pref_id_it == iter_id) {
         if (update_gallery_type)
           dict->SetString(kMediaGalleriesTypeKey, TypeToStringValue(new_type));
         if (update_gallery_name)
           dict->SetString(kMediaGalleriesDisplayNameKey, display_name);
         if (update_gallery_metadata) {
           dict->SetString(kMediaGalleriesVolumeLabelKey, volume_label);
           dict->SetString(kMediaGalleriesVendorNameKey, vendor_name);
           dict->SetString(kMediaGalleriesModelNameKey, model_name);
           dict->SetDouble(kMediaGalleriesSizeKey, total_size_in_bytes);
           dict->SetDouble(kMediaGalleriesLastAttachTimeKey,
                           last_attach_time.ToInternalValue());
         }
+        if (update_scan_counts) {
+          dict->SetInteger(kMediaGalleriesScanImageCountKey, image_count);
+          dict->SetInteger(kMediaGalleriesScanMusicCountKey, music_count);
+          dict->SetInteger(kMediaGalleriesScanVideoCountKey, video_count);
+        }
         dict->SetInteger(kMediaGalleriesPrefsVersionKey, prefs_version);
         break;
       }
     }
 
     // Commits the prefs update.
     update.reset();
 
-    if (update_gallery_name || update_gallery_metadata || update_gallery_type) {
-      InitFromPrefs();
-      FOR_EACH_OBSERVER(GalleryChangeObserver,
-                        gallery_change_observers_,
-                        OnGalleryInfoUpdated(this, *pref_id_it));
-    }
+    InitFromPrefs();
+    FOR_EACH_OBSERVER(GalleryChangeObserver, gallery_change_observers_,
+                      OnGalleryInfoUpdated(this, *pref_id_it));
     return *pref_id_it;
   }
 
   PrefService* prefs = profile_->GetPrefs();
 
   MediaGalleryPrefInfo gallery_info;
   gallery_info.pref_id = prefs->GetUint64(prefs::kMediaGalleriesUniqueId);
   prefs->SetUint64(prefs::kMediaGalleriesUniqueId, gallery_info.pref_id + 1);
   gallery_info.display_name = display_name;
   gallery_info.device_id = device_id;
   gallery_info.path = normalized_relative_path;
   gallery_info.type = type;
-  if (volume_metadata_valid) {

[Lei Zhang, 2014/01/15 22:13:43]

Why is this changing?

[vandebo (ex-Chrome), 2014/01/15 22:19:44]

The thing below this conditionally sets the fields, so it seems like a minor
clean up to just set all of the things here and let the thing below do what it
wants.  Instead of doing it multiple times, or in the worse case, doing
different things in the two places.

[Lei Zhang, 2014/01/15 22:38:23]

Right now this change is a no-op because every place where we pass in
|volume_metadata_valid| as false, we also pass dummy values for the parameters
in the if block. However, if a caller does not pass in dummy values, then the
behavior changes in a way that does not make sense.

I'd either preserve the current behavior, or get rid of |volume_metadata_valid|
and infer it from the other parameters.

[vandebo (ex-Chrome), 2014/01/15 22:43:05]

I don't see that: in CreateGalleryPrefInfoDictionary, if volume_metadata_valid
is true, we set the values in preferences, if not, we don't. line 240

-    gallery_info.volume_label = volume_label;
-    gallery_info.vendor_name = vendor_name;
-    gallery_info.model_name = model_name;
-    gallery_info.total_size_in_bytes = total_size_in_bytes;
-    gallery_info.last_attach_time = last_attach_time;
-  }
+  gallery_info.volume_label = volume_label;
+  gallery_info.vendor_name = vendor_name;
+  gallery_info.model_name = model_name;
+  gallery_info.total_size_in_bytes = total_size_in_bytes;
+  gallery_info.last_attach_time = last_attach_time;
   gallery_info.volume_metadata_valid = volume_metadata_valid;
+  gallery_info.image_count = image_count;
+  gallery_info.music_count = music_count;
+  gallery_info.video_count = video_count;
   gallery_info.prefs_version = prefs_version;
 
   {
     ListPrefUpdate update(prefs, prefs::kMediaGalleriesRememberedGalleries);
     base::ListValue* list = update.Get();
     list->Append(CreateGalleryPrefInfoDictionary(gallery_info));
   }
   InitFromPrefs();
   FOR_EACH_OBSERVER(GalleryChangeObserver,
                     gallery_change_observers_,
@@ skipping 13 matching lines @@
   return AddGalleryInternal(gallery_info.device_id,
                             gallery_info.display_name,
                             gallery_info.path,
                             type,
                             gallery_info.volume_label,
                             gallery_info.vendor_name,
                             gallery_info.model_name,
                             gallery_info.total_size_in_bytes,
                             gallery_info.last_attach_time,
                             gallery_info.volume_metadata_valid,
-                            gallery_info.prefs_version);
+                            0, 0, 0,
+                            kCurrentPrefsVersion);
 }
 
 void MediaGalleriesPreferences::ForgetGalleryById(MediaGalleryPrefId pref_id) {
   DCHECK(IsInitialized());
   PrefService* prefs = profile_->GetPrefs();
   scoped_ptr<ListPrefUpdate> update(new ListPrefUpdate(
       prefs, prefs::kMediaGalleriesRememberedGalleries));
   base::ListValue* list = update->Get();
 
   if (!ContainsKey(known_galleries_, pref_id))
     return;
 
   for (base::ListValue::iterator iter = list->begin();
        iter != list->end(); ++iter) {
     base::DictionaryValue* dict;
     MediaGalleryPrefId iter_id;
     if ((*iter)->GetAsDictionary(&dict) && GetPrefId(*dict, &iter_id) &&
         pref_id == iter_id) {
       RemoveGalleryPermissionsFromPrefs(pref_id);
       MediaGalleryPrefInfo::Type type;
       if (GetType(*dict, &type) &&
           (type == MediaGalleryPrefInfo::kAutoDetected ||
            type == MediaGalleryPrefInfo::kScanResult)) {
         if (type == MediaGalleryPrefInfo::kAutoDetected) {
           dict->SetString(kMediaGalleriesTypeKey,
                           kMediaGalleriesTypeBlackListedValue);
         } else {
           dict->SetString(kMediaGalleriesTypeKey,
                           kMediaGalleriesTypeRemovedScanValue);
+          dict->SetInteger(kMediaGalleriesScanImageCountKey, 0);
+          dict->SetInteger(kMediaGalleriesScanMusicCountKey, 0);
+          dict->SetInteger(kMediaGalleriesScanVideoCountKey, 0);
         }
       } else {
         list->Erase(iter, NULL);
       }
       update.reset(NULL);  // commits the update.
 
       InitFromPrefs();
       FOR_EACH_OBSERVER(GalleryChangeObserver,
                         gallery_change_observers_,
                         OnGalleryRemoved(this, pref_id));
@@ skipping 215 matching lines @@
   if (extension_prefs_for_testing_)
     return extension_prefs_for_testing_;
   return extensions::ExtensionPrefs::Get(profile_);
 }
 
 void MediaGalleriesPreferences::SetExtensionPrefsForTesting(
     extensions::ExtensionPrefs* extension_prefs) {
   DCHECK(IsInitialized());
   extension_prefs_for_testing_ = extension_prefs;
 }