Store Media gallery permissions in extension prefs.

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/admin_policy.h"
@@ skipping 160 matching lines @@
 // background page.
 const char kRegisteredEvents[] = "events";
 
 // A dictionary of event names to lists of filters that this extension has
 // registered from its lazy background page.
 const char kFilteredEvents[] = "filtered_events";
 
 // Persisted value for omnibox.setDefaultSuggestion.
 const char kOmniboxDefaultSuggestion[] = "omnibox_default_suggestion";
 
+// List of media gallery permissions.
+const char kMediaGalleriesPermissions[] = "media_galleries_permissions";
+
+// Key for Media Gallery ID.
+const char kMediaGalleryIdKey[] = "id";
+
+// Key for Media Gallery Permission Value.
+const char kMediaGalleryHasPermissionKey[] = "has_permission";
+
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedExtensionPrefUpdate(PrefService* service,
                             const std::string& extension_id) :
     DictionaryPrefUpdate(service, ExtensionPrefs::kExtensionsPref),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
   }
@@ skipping 952 matching lines @@
 
   return result;
 }
 
 void ExtensionPrefs::SetLaunchType(const std::string& extension_id,
                                    LaunchType launch_type) {
   UpdateExtensionPref(extension_id, kPrefLaunchType,
       Value::CreateIntegerValue(static_cast<int>(launch_type)));
 }
 
+namespace {
+
+bool GetMediaGalleryPermissionFromDictionary(
+    const DictionaryValue* dict,
+    MediaGalleryPermission* out_permission) {
+  std::string string_id;
+  if (dict->GetString(kMediaGalleryIdKey, &string_id) &&
+      base::StringToUint64(string_id, &out_permission->pref_id) &&
+      dict->GetBoolean(kMediaGalleryHasPermissionKey,
+        &out_permission->has_permission)) {
+    return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
+void RemoveMediaGalleryPermissionsFromExtension(PrefService * prefs,
+                                                const std::string& extension_id,
+                                                MediaGalleryPrefId gallery_id) {
+  ScopedExtensionPrefUpdate update(prefs, extension_id);
+  DictionaryValue* extension_dict = update.Get();
+  ListValue* permissions = NULL;
+  if (!extension_dict->GetList(kMediaGalleriesPermissions, &permissions))
+    return;
+
+  for (ListValue::iterator it = permissions->begin();
+       it != permissions->end();
+       it++) {
+    const DictionaryValue* dict = NULL;
+    if (!(*it)->GetAsDictionary(&dict))
+      continue;
+    MediaGalleryPermission perm;
+    if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
+      continue;
+    if (perm.pref_id == gallery_id) {
+      permissions->Erase(it, NULL);
+      return;
+    }
+  }
+}
+
+}  // namespace
+
+void ExtensionPrefs::SetMediaGalleryPermission(const std::string& extension_id,
+                                               MediaGalleryPrefId gallery,
+                                               bool has_access) {
+  ScopedExtensionPrefUpdate update(prefs_, extension_id);
+  DictionaryValue* extension_dict = update.Get();
+  ListValue* permissions = NULL;
+  if (!extension_dict->GetList(kMediaGalleriesPermissions, &permissions)) {
+    permissions = new ListValue;
+    extension_dict->Set(kMediaGalleriesPermissions, permissions);
+  } else {
+    // If the gallery is already in the list, update the permission.
+    for (ListValue::const_iterator it = permissions->begin();
+         it != permissions->end();
+         it++) {
+      DictionaryValue* dict = NULL;
+      if (!(*it)->GetAsDictionary(&dict))
+        continue;
+      MediaGalleryPermission perm;
+      if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
+        continue;
+      if (perm.pref_id == gallery) {
+        dict->SetBoolean(kMediaGalleryHasPermissionKey, has_access);
+        return;
+      }
+    }
+  }
+
+  DictionaryValue* dict = new DictionaryValue;
+  dict->SetString(kMediaGalleryIdKey, base::Uint64ToString(gallery));
+  dict->SetBoolean(kMediaGalleryHasPermissionKey, has_access);
+  permissions->Append(dict);
+}
+
+std::vector<MediaGalleryPermission> ExtensionPrefs::GetMediaGalleryPermissions(
+        const std::string& extension_id) {
+  std::vector<MediaGalleryPermission> result;
+  const ListValue* permissions = NULL;
+  if (ReadExtensionPrefList(extension_id, kMediaGalleriesPermissions,
+                            &permissions)) {
+    for (ListValue::const_iterator it = permissions->begin();
+         it != permissions->end();
+         it++) {
+      DictionaryValue* dict = NULL;
+      if (!(*it)->GetAsDictionary(&dict))
+        continue;
+      MediaGalleryPermission perm;
+      if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
+        continue;
+      result.push_back(perm);
+    }
+  }
+  return result;
+}
+
+void ExtensionPrefs::RemoveMediaGalleryPermissions(
+    MediaGalleryPrefId gallery_id) {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions)
+    return;
+
+  for (DictionaryValue::key_iterator iter = extensions->begin_keys();
+       iter != extensions->end_keys(); ++iter) {
+    const std::string& id(*iter);
+    if (!Extension::IdIsValid(id)) {
+      NOTREACHED();
+      continue;
+    }
+    RemoveMediaGalleryPermissionsFromExtension(prefs_, id, gallery_id);
+  }
+}
+
 bool ExtensionPrefs::DoesExtensionHaveState(
     const std::string& id, Extension::State check_state) const {
   const DictionaryValue* extension = GetExtensionPref(id);
   int state = -1;
   if (!extension || !extension->GetInteger(kPrefState, &state))
     return false;
 
   if (state < 0 || state >= Extension::NUM_STATES) {
     LOG(ERROR) << "Bad pref 'state' for extension '" << id << "'";
     return false;
@@ skipping 771 matching lines @@
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions