Clean up media gallery preferences.

chrome/browser/media_gallery/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_gallery/media_galleries_preferences.h"
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 98 matching lines @@
       type = kMediaGalleriesTypeBlackListedValue;
       break;
     default:
       NOTREACHED();
       break;
   }
   dict->SetString(kMediaGalleriesTypeKey, type);
   return dict;
 }
 
-bool FindPrefIdFromDeviceId(const MediaGalleriesPrefInfoMap& known_galleries,
-                            const std::string& device_id,
-                            MediaGalleryPrefId* pref_id)  {
-  // TODO(vandebo) Handle multiple galleries that use different paths.
-  // TODO(vandebo) Should we keep a second map device_id->pref_id?
-  for (MediaGalleriesPrefInfoMap::const_iterator it = known_galleries.begin();
-       it != known_galleries.end();
-       ++it) {
-    if (it->second.device_id == device_id) {
-      if (pref_id)
-        *pref_id = it->second.pref_id;
-      return true;
-    }
-  }
-  return false;
-}
-
 FilePath MakePathRelative(FilePath path) {
   if (!path.IsAbsolute())
     return path;
 
   FilePath relative;
   std::vector<FilePath::StringType> components;
   path.GetComponents(&components);
 
   // On Windows, the first component may be the drive letter with the second
   // being \\.
@@ skipping 29 matching lines @@
       AddGallery(device_id, display_name, pictures_path, false /*user added*/);
     }
   }
   InitFromPrefs();
 }
 
 MediaGalleriesPreferences::~MediaGalleriesPreferences() {}
 
 void MediaGalleriesPreferences::InitFromPrefs() {
   known_galleries_.clear();
+  device_map_.clear();
 
   PrefService* prefs = profile_->GetPrefs();
   const ListValue* list = prefs->GetList(
       prefs::kMediaGalleriesRememberedGalleries);
   if (!list)
     return;
 
   for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
     const DictionaryValue* dict = NULL;
     if (!(*it)->GetAsDictionary(&dict))
       continue;
 
     MediaGalleryPrefInfo gallery_info;
     if (PopulateGalleryPrefInfoFromDictionary(*dict, &gallery_info))
       known_galleries_[gallery_info.pref_id] = gallery_info;
+      device_map_[gallery_info.device_id].insert(gallery_info.pref_id);

[Lei Zhang, 2012/09/15 01:17:17]

I think you are missing brackets after the if statement.....

   }
 }
 
 bool MediaGalleriesPreferences::LookUpGalleryByPath(
     const FilePath& path,
     MediaGalleryPrefInfo* gallery_info) const {
   std::string device_id =
       MediaFileSystemRegistry::GetInstance()->GetDeviceIdFromPath(path);
-  MediaGalleryPrefId pref_id;
-  if (!FindPrefIdFromDeviceId(known_galleries_, device_id, &pref_id)) {
-    if (gallery_info) {
-      gallery_info->pref_id = kInvalidMediaGalleryPrefId;
-      gallery_info->display_name = ComputeDisplayName(path);
-      gallery_info->device_id = device_id;
-      gallery_info->path = MakePathRelative(path);
-      gallery_info->type = MediaGalleryPrefInfo::kUserAdded;
-    }
-    return false;
+  FilePath relative_path = MakePathRelative(path);
+  MediaGalleryPrefIdSet galleries_on_device =
+    LookUpGalleriesByDeviceId(device_id);
+  for (MediaGalleryPrefIdSet::const_iterator it = galleries_on_device.begin();
+       it != galleries_on_device.end();
+       ++it) {
+    const MediaGalleryPrefInfo& gallery = known_galleries_.find(*it)->second;
+    if (gallery.path != relative_path)
+      continue;
+
+    if (gallery_info)
+      *gallery_info = gallery;
+    return true;
   }
 
   if (gallery_info) {
-    MediaGalleriesPrefInfoMap::const_iterator it =
-        known_galleries_.find(pref_id);
-    DCHECK(it != known_galleries_.end());
-    *gallery_info = it->second;
+    gallery_info->pref_id = kInvalidMediaGalleryPrefId;
+    gallery_info->display_name = ComputeDisplayName(path);
+    gallery_info->device_id = device_id;
+    gallery_info->path = relative_path;
+    gallery_info->type = MediaGalleryPrefInfo::kUserAdded;
   }
-  return true;
+  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()) {
+    MediaGalleryPrefIdSet result;
+    return result;
+  }
+
+  return found->second;
+}
+
+
 MediaGalleryPrefId MediaGalleriesPreferences::AddGallery(
     const std::string& device_id, const string16& display_name,
     const FilePath& path, bool user_added) {
   DCHECK(display_name.length() > 0);
-  MediaGalleryPrefId existing_id;
-  if (FindPrefIdFromDeviceId(known_galleries_, device_id, &existing_id)) {
-    const MediaGalleryPrefInfo& existing = known_galleries_[existing_id];
+  FilePath relative_path = MakePathRelative(path);
+  MediaGalleryPrefIdSet galleries_on_device =
+    LookUpGalleriesByDeviceId(device_id);
+  for (MediaGalleryPrefIdSet::const_iterator it = galleries_on_device.begin();
+       it != galleries_on_device.end();
+       ++it) {
+    if (known_galleries_[*it].path != relative_path)
+      continue;
+
+    const MediaGalleryPrefInfo& existing = known_galleries_[*it];
     if (existing.type == MediaGalleryPrefInfo::kBlackListed) {
       PrefService* prefs = profile_->GetPrefs();
       ListPrefUpdate update(prefs, prefs::kMediaGalleriesRememberedGalleries);
       ListValue* list = update.Get();
 
-      for (ListValue::const_iterator it = list->begin();
-           it != list->end();
-           ++it) {
+      for (ListValue::const_iterator list_iter = list->begin();
+           list_iter != list->end();
+           ++list_iter) {
         DictionaryValue* dict;
         MediaGalleryPrefId iter_id;
-        if ((*it)->GetAsDictionary(&dict) &&
+        if ((*list_iter)->GetAsDictionary(&dict) &&
             GetPrefId(*dict, &iter_id) &&
-            existing_id == iter_id) {
+            *it == iter_id) {
           dict->SetString(kMediaGalleriesTypeKey,
                           kMediaGalleriesTypeAutoDetectedValue);
           InitFromPrefs();
           break;
         }
       }
     }
-    return existing_id;
+    return *it;
   }
 
-  FilePath relative_path = MakePathRelative(path);
   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 = relative_path;
   gallery_info.type = MediaGalleryPrefInfo::kAutoDetected;
   if (user_added)
@@ skipping 13 matching lines @@
       MediaFileSystemRegistry::GetInstance()->GetDeviceIdFromPath(path);
   string16 display_name = ComputeDisplayName(path);
   return AddGallery(device_id, display_name, path, true);
 }
 
 void MediaGalleriesPreferences::ForgetGalleryById(MediaGalleryPrefId pref_id) {
   PrefService* prefs = profile_->GetPrefs();
   ListPrefUpdate update(prefs, prefs::kMediaGalleriesRememberedGalleries);
   ListValue* list = update.Get();
 
+  if (known_galleries_.find(pref_id) == known_galleries_.end())
+    return;
+
   for (ListValue::iterator iter = list->begin(); iter != list->end(); ++iter) {
     DictionaryValue* dict;
     MediaGalleryPrefId iter_id;
     if ((*iter)->GetAsDictionary(&dict) && GetPrefId(*dict, &iter_id) &&
         pref_id == iter_id) {
       GetExtensionPrefs()->RemoveMediaGalleryPermissions(pref_id);
       MediaGalleryPrefInfo::Type type;
       if (GetType(*dict, &type) &&
           type == MediaGalleryPrefInfo::kAutoDetected) {
         dict->SetString(kMediaGalleriesTypeKey,
                         kMediaGalleriesTypeBlackListedValue);
       } else {
         list->Erase(iter, NULL);
       }
       InitFromPrefs();
       return;
     }
   }
 }
 
-std::set<MediaGalleryPrefId>
-MediaGalleriesPreferences::GalleriesForExtension(
+MediaGalleryPrefIdSet MediaGalleriesPreferences::GalleriesForExtension(
     const extensions::Extension& extension) const {
-  std::set<MediaGalleryPrefId> result;
+  MediaGalleryPrefIdSet result;
   if (extension.HasAPIPermission(
           extensions::APIPermission::kMediaGalleriesAllGalleries)) {
     for (MediaGalleriesPrefInfoMap::const_iterator it =
              known_galleries_.begin(); it != known_galleries_.end(); ++it) {
       if (it->second.type == MediaGalleryPrefInfo::kAutoDetected)
         result.insert(it->second.pref_id);
     }
   }
 
   std::vector<MediaGalleryPermission> stored_permissions =
@@ skipping 14 matching lines @@
       }
     }
   }
   return result;
 }
 
 void MediaGalleriesPreferences::SetGalleryPermissionForExtension(
     const extensions::Extension& extension,
     MediaGalleryPrefId pref_id,
     bool has_permission) {
+  // The gallery may not exist anymore if the user opened a second config
+  // surface concurrently and removed it. Drop the permission update if so.
+  MediaGalleriesPrefInfoMap::iterator gallery_info =
+      known_galleries_.find(pref_id);
+  if (gallery_info == known_galleries_.end())
+    return;
+
   bool all_permission = extension.HasAPIPermission(
       extensions::APIPermission::kMediaGalleriesAllGalleries);
   if (has_permission && all_permission) {
-    MediaGalleriesPrefInfoMap::iterator gallery_info =
-        known_galleries_.find(pref_id);
-    DCHECK(gallery_info != known_galleries_.end());
     if (gallery_info->second.type == MediaGalleryPrefInfo::kAutoDetected) {
       GetExtensionPrefs()->UnsetMediaGalleryPermission(extension.id(), pref_id);
       return;
     }
   }
 
   if (!has_permission && !all_permission) {
     GetExtensionPrefs()->UnsetMediaGalleryPermission(extension.id(), pref_id);
   } else {
     GetExtensionPrefs()->SetMediaGalleryPermission(extension.id(), pref_id,
@@ skipping 30 matching lines @@
 }
 
 extensions::ExtensionPrefs*
 MediaGalleriesPreferences::GetExtensionPrefs() const {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   return extension_service->extension_prefs();
 }
 
 } // namespace chrome