Store Media gallery permissions in extension prefs.

BUG=NONE


Review URL: https://chromiumcodereview.appspot.com/10824116

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@149658 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/extensions/extension_prefs.cc

@@ -178,6 +178,15 @@ 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:
@@ -1150,6 +1159,121 @@ void ExtensionPrefs::SetLaunchType(const std::string& extension_id,
       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 it = extensions->begin_keys();
+       it != extensions->end_keys();
+       ++it) {
+    const std::string& id(*it);
+    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);

chrome/browser/extensions/extension_prefs.h

@@ -16,6 +16,7 @@
 #include "chrome/browser/extensions/extension_prefs_scope.h"
 #include "chrome/browser/extensions/extension_scoped_prefs.h"
 #include "chrome/browser/extensions/management_policy.h"
+#include "chrome/browser/media_gallery/media_galleries_preferences.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "chrome/common/string_ordinal.h"
@@ -321,6 +322,14 @@ class ExtensionPrefs : public ContentSettingsStore::Observer,
       const Extension* extension,
       LaunchType default_pref_value);
 
+  // Set and retrieve permissions for media galleries as identified by the
+  // gallery id.
+  void SetMediaGalleryPermission(const std::string& extension_id,
+                                 MediaGalleryPrefId gallery, bool has_access);
+  std::vector<MediaGalleryPermission> GetMediaGalleryPermissions(
+      const std::string& extension_id);
+  void RemoveMediaGalleryPermissions(MediaGalleryPrefId gallery_id);
+
   // Saves ExtensionInfo for each installed extension with the path to the
   // version directory and the location. Blacklisted extensions won't be saved
   // and neither will external extensions the user has explicitly uninstalled.

chrome/browser/extensions/extension_prefs_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "extension_prefs_unittest.h"
 
+#include "base/basictypes.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
@@ -101,6 +102,97 @@ class ExtensionPrefsLastPingDay : public ExtensionPrefsTest {
 };
 TEST_F(ExtensionPrefsLastPingDay, LastPingDay) {}
 
+namespace {
+
+void AddGalleryPermission(MediaGalleryPrefId gallery, bool has_access,
+                          std::vector<MediaGalleryPermission>* vector) {
+  MediaGalleryPermission permission;
+  permission.pref_id = gallery;
+  permission.has_permission = has_access;
+  vector->push_back(permission);
+}
+
+}  // namspace
+
+// Test the MediaGalleries permissions functions.
+class MediaGalleriesPermissions : public ExtensionPrefsTest {
+ public:
+  virtual void Initialize() {
+    extension1_id_ = prefs_.AddExtensionAndReturnId("test1");
+    extension2_id_ = prefs_.AddExtensionAndReturnId("test2");
+    extension3_id_ = prefs_.AddExtensionAndReturnId("test3");
+    // Id4 isn't used to ensure that an empty permission list is ok.
+    extension4_id_ = prefs_.AddExtensionAndReturnId("test4");
+    Verify();
+
+    prefs()->SetMediaGalleryPermission(extension1_id_, 1, false);
+    AddGalleryPermission(1, false, &extension1_expectation_);
+    Verify();
+
+    prefs()->SetMediaGalleryPermission(extension1_id_, 2, true);
+    AddGalleryPermission(2, true, &extension1_expectation_);
+    Verify();
+
+    prefs()->SetMediaGalleryPermission(extension1_id_, 2, false);
+    extension1_expectation_[1].has_permission = false;
+    Verify();
+
+    prefs()->SetMediaGalleryPermission(extension2_id_, 1, true);
+    prefs()->SetMediaGalleryPermission(extension2_id_, 3, true);
+    prefs()->SetMediaGalleryPermission(extension2_id_, 4, true);
+    AddGalleryPermission(1, true, &extension2_expectation_);
+    AddGalleryPermission(3, true, &extension2_expectation_);
+    AddGalleryPermission(4, true, &extension2_expectation_);
+    Verify();
+
+    prefs()->SetMediaGalleryPermission(extension3_id_, 3, true);
+    AddGalleryPermission(3, true, &extension3_expectation_);
+    Verify();
+
+    prefs()->RemoveMediaGalleryPermissions(3);
+    extension2_expectation_.erase(extension2_expectation_.begin() + 1);
+    extension3_expectation_.erase(extension3_expectation_.begin());
+    Verify();
+  }
+
+  virtual void Verify() {
+    struct TestData {
+      std::string* id;
+      std::vector<MediaGalleryPermission>* expectation;
+    };
+
+    const TestData test_data[] = {{&extension1_id_, &extension1_expectation_},
+                                  {&extension2_id_, &extension2_expectation_},
+                                  {&extension3_id_, &extension3_expectation_},
+                                  {&extension4_id_, &extension4_expectation_}};
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); i++) {
+      std::vector<MediaGalleryPermission> actual =
+          prefs()->GetMediaGalleryPermissions(*test_data[i].id);
+      EXPECT_EQ(test_data[i].expectation->size(), actual.size());
+      for (size_t permission_entry = 0;
+           permission_entry < test_data[i].expectation->size() &&
+               permission_entry < actual.size();
+           permission_entry++) {
+        EXPECT_EQ(test_data[i].expectation->at(permission_entry).pref_id,
+                  actual[permission_entry].pref_id);
+        EXPECT_EQ(test_data[i].expectation->at(permission_entry).has_permission,
+                  actual[permission_entry].has_permission);
+      }
+    }
+  }
+
+ private:
+  std::string extension1_id_;
+  std::string extension2_id_;
+  std::string extension3_id_;
+  std::string extension4_id_;
+
+  std::vector<MediaGalleryPermission> extension1_expectation_;
+  std::vector<MediaGalleryPermission> extension2_expectation_;
+  std::vector<MediaGalleryPermission> extension3_expectation_;
+  std::vector<MediaGalleryPermission> extension4_expectation_;
+};
+TEST_F(MediaGalleriesPermissions, MediaGalleries) {}
 
 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {

chrome/browser/media_gallery/media_galleries_preferences.h

@@ -13,12 +13,19 @@
 #include "base/string16.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 
+class PrefService;
+class Profile;
+
 namespace base {
 class DictionaryValue;
 }
 
-class PrefService;
-class Profile;
+typedef uint64 MediaGalleryPrefId;
+
+struct MediaGalleryPermission {
+  MediaGalleryPrefId pref_id;
+  bool has_permission;
+};
 
 struct MediaGallery {
   MediaGallery();