Track permissions granted to extensions in prefs

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2010 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_util.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 
 using base::Time;
 
 namespace {
 
 // Additional preferences keys
 
 // Where an extension was installed from. (see Extension::Location)
@@ skipping 54 matching lines @@
 
 // A preference determining the order of which the apps appear on the NTP.
 const char kPrefAppLaunchIndex[] = "app_launcher_index";
 
 // A preference for storing extra data sent in update checks for an extension.
 const char kUpdateUrlData[] = "update_url_data";
 
 // Whether the browser action is visible in the toolbar.
 const char kBrowserActionVisible[] = "browser_action_visible";
 
+// Preferences that hold the permissions the user has granted the extension.
+// We explicitly keep track of these so that extensions can contain unknown
+// permissions, for backwards compatibility reasons, and we can still prompt
+// the user to accept them once recognized.
+const char kPrefGrantedPermissionsAPI[] = "granted_permissions.api";
+const char kPrefGrantedPermissionsHost[] = "granted_permissions.host";
+const char kPrefGrantedPermissionsInitialized[] =
+    "granted_permissions.initialized";
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 // TODO(asargent) - This is cleanup code for a key that was introduced into
 // the extensions.settings sub-dictionary which wasn't a valid extension
 // id. We can remove this in a couple of months. (See http://crbug.com/40017
 // and http://crbug.com/39745 for more details).
@@ skipping 11 matching lines @@
   bool dirty = false;
   for (std::set<std::string>::iterator i = bad_keys.begin();
        i != bad_keys.end(); ++i) {
     dirty = true;
     dictionary->Remove(*i, NULL);
   }
   if (dirty)
     prefs->ScheduleSavePersistentPrefs();
 }
 
+static void ExtentToStringSet(const ExtensionExtent& host_extent,
+                              std::set<std::string>* result) {
+  ExtensionExtent::PatternList patterns = host_extent.patterns();
+  ExtensionExtent::PatternList::const_iterator i;
+
+  for (i = patterns.begin(); i != patterns.end(); ++i)
+    result->insert(i->GetAsString());
+}
+
+static void AddPattern(ExtensionExtent* extent, const std::string& pattern) {
+  int schemes = URLPattern::SCHEME_ALL;
+  extent->AddPattern(URLPattern(schemes, pattern));
+}
+
 }  // namespace
 
 ExtensionPrefs::ExtensionPrefs(PrefService* prefs, const FilePath& root_dir)
     : prefs_(prefs),
       install_directory_(root_dir) {
   // TODO(asargent) - Remove this in a couple of months. (See comment above
   // CleanupBadExtensionKeys).
   CleanupBadExtensionKeys(prefs);
 
   MakePathsRelative();
@@ skipping 85 matching lines @@
     DictionaryValue* copy =
         static_cast<DictionaryValue*>(extensions->DeepCopy());
     MakePathsAbsolute(copy);
     return copy;
   }
   return new DictionaryValue;
 }
 
 bool ExtensionPrefs::ReadBooleanFromPref(
     DictionaryValue* ext, const std::string& pref_key) {
-  if (!ext->HasKey(pref_key)) return false;
   bool bool_value = false;
-  if (!ext->GetBoolean(pref_key, &bool_value)) {
-    NOTREACHED() << "Failed to fetch " << pref_key << " flag.";
-    // In case we could not fetch the flag, we treat it as false.
+  if (!ext->GetBoolean(pref_key, &bool_value))
     return false;
-  }
+
   return bool_value;
 }
 
 bool ExtensionPrefs::ReadExtensionPrefBoolean(
     const std::string& extension_id, const std::string& pref_key) {
-  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
-  if (!extensions)
-    return false;
-
-  DictionaryValue* ext = NULL;
-  if (!extensions->GetDictionary(extension_id, &ext)) {
+  DictionaryValue* ext = GetExtensionPref(extension_id);
+  if (!ext) {
     // No such extension yet.
     return false;
   }
   return ReadBooleanFromPref(ext, pref_key);
 }
 
 bool ExtensionPrefs::ReadIntegerFromPref(
     DictionaryValue* ext, const std::string& pref_key, int* out_value) {
-  if (!ext->HasKey(pref_key)) return false;
-  if (!ext->GetInteger(pref_key, out_value)) {
-    NOTREACHED() << "Failed to fetch " << pref_key << " flag.";
-    // In case we could not fetch the flag, we treat it as false.
+  if (!ext->GetInteger(pref_key, out_value))
     return false;
-  }
+
   return out_value != NULL;
 }
 
 bool ExtensionPrefs::ReadExtensionPrefInteger(
     const std::string& extension_id, const std::string& pref_key,
     int* out_value) {
-  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
-  if (!extensions)
-    return false;
-  DictionaryValue* ext = NULL;
-  if (!extensions->GetDictionary(extension_id, &ext)) {
+  DictionaryValue* ext = GetExtensionPref(extension_id);
+  if (!ext) {
     // No such extension yet.
     return false;
   }
   return ReadIntegerFromPref(ext, pref_key, out_value);
 }
 
+bool ExtensionPrefs::ReadExtensionPrefList(
+    const std::string& extension_id, const std::string& pref_key,
+    ListValue** out_value) {
+  DictionaryValue* ext = GetExtensionPref(extension_id);
+  if (!ext || !ext->GetList(pref_key, out_value))
+    return false;
+
+  return out_value != NULL;
+}
+
+bool ExtensionPrefs::ReadExtensionPrefStringSet(
+    const std::string& extension_id,
+    const std::string& pref_key,
+    std::set<std::string>* result) {
+  DCHECK(Extension::IdIsValid(extension_id));
+  DCHECK(result);
+
+  ListValue* value = NULL;
+  if (!ReadExtensionPrefList(extension_id, pref_key, &value))
+    return false;
+
+  result->clear();
+
+  for (size_t i = 0; i < value->GetSize(); ++i) {
+    std::string item;
+    if (!value->GetString(i, &item))
+      return false;
+    result->insert(item);
+  }
+
+  return true;
+}
+
+void ExtensionPrefs::AddToExtensionPrefStringSet(
+    const std::string& extension_id,
+    const std::string& pref_key,
+    const std::set<std::string>& added_value) {
+  DCHECK(Extension::IdIsValid(extension_id));
+
+  std::set<std::string> old_value;
+  std::set<std::string> new_value;
+  ReadExtensionPrefStringSet(extension_id, pref_key, &old_value);
+
+  std::set_union(old_value.begin(), old_value.end(),
+                 added_value.begin(), added_value.end(),
+                 std::inserter(new_value, new_value.end()));
+
+  ListValue* value = new ListValue();
+  for (std::set<std::string>::const_iterator iter = new_value.begin();
+       iter != new_value.end(); ++iter)
+    value->Append(Value::CreateStringValue(*iter));
+
+  UpdateExtensionPref(extension_id, pref_key, value);
+  prefs_->ScheduleSavePersistentPrefs();
+}
+
 void ExtensionPrefs::SavePrefsAndNotify() {
   prefs_->ScheduleSavePersistentPrefs();
   prefs_->pref_notifier()->OnUserPreferenceSet(kExtensionsPref);
 }
 
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
@@ skipping 124 matching lines @@
                                         DictionaryValue* dictionary) {
   if (!dictionary) {
     NOTREACHED();
     return;
   }
   std::string value = base::Int64ToString(time.ToInternalValue());
   dictionary->SetString(kLastPingDay, value);
   SavePrefsAndNotify();
 }
 
+
+bool ExtensionPrefs::GetGrantedPermissions(
+    const std::string& extension_id,
+    std::set<std::string>* api_permissions,
+    ExtensionExtent* host_extent) {
+  DCHECK(Extension::IdIsValid(extension_id));

[Aaron Boodman, 2010/11/22 07:57:53]

You can leave these if you like, but it's a little over-paranoid compared to the
rest of Chrome IMO. We don't typically assert input arguments are valid.

Up to you though.

If you do leave it: DCHECK->CHECK

[jstritar, 2010/11/22 23:01:08]

Got rid of all of them except the Extension::IdIsValid check, and renamed that
one to CHECK.

+  DCHECK(api_permissions);
+  DCHECK(host_extent);
+
+  if (!ReadExtensionPrefBoolean(extension_id,
+                                kPrefGrantedPermissionsInitialized))
+    return false;
+
+  ReadExtensionPrefStringSet(
+      extension_id, kPrefGrantedPermissionsAPI, api_permissions);
+
+  std::set<std::string> host_permissions;
+  ReadExtensionPrefStringSet(
+      extension_id, kPrefGrantedPermissionsHost, &host_permissions);
+
+  for (std::set<std::string>::iterator i = host_permissions.begin();
+       i != host_permissions.end(); ++i)
+    AddPattern(host_extent, *i);

[Aaron Boodman, 2010/11/22 07:57:53]

No need for the helper function here since what it is doing is just one line
anyway. Also, you should use the same valid schemes as Extension uses when it
creates its own host permissions during parse. You might want to expose the
value Extension uses to avoid duplication.

[jstritar, 2010/11/22 23:01:08]

Done.

+
+  return true;
+}
+
+void ExtensionPrefs::AddGrantedPermissions(
+    const std::string& extension_id,
+    const std::set<std::string>& api_permissions,
+    const ExtensionExtent& host_extent) {
+  DCHECK(Extension::IdIsValid(extension_id));

[Aaron Boodman, 2010/11/22 07:57:53]

DCHECK->CHECK

[jstritar, 2010/11/22 23:01:08]

Done.

+  UpdateExtensionPref(extension_id, kPrefGrantedPermissionsInitialized,

[Aaron Boodman, 2010/11/22 07:57:53]

Is it possible to remove this and just use the presence of the subtree itself as
a flag that it has been initialized?

[jstritar, 2010/11/22 23:01:08]

I think we need this because empty lists and dictionaries get pruned from the
tree when it's serialized, so we can't distinguish between it not being
initialized and the extension having no permissions.

[Aaron Boodman, 2010/11/23 00:06:38]

I see. It's a shame to bloat the preferences file with this extra bit of state
if every single object. It would be better if we could migrate the preferences
file once and write out all these granted permissions, and then assume from then
forward that if there are no granted permissions it means the user granted no
permissions.

We have a pattern for this in other parts of Chrome. See
chrome/browser/dom_ui/new_tab_ui.cc ::UpdateUserPrefsVersion() for one example
of it.

Right now there are two subsystems that I can see that do this: NTP and Content
Settings. We might want to consider making one master pref_version key for the
entire Preferences file and having a MigrateUserPrefs in Profile and calling all
the components that have migration code from there, just like we do today for
RegisterUserPrefs.

But again that could be a separate refactor. For now, at least please add the
preference_version key and migration code to ExtensionPrefs.

+                      Value::CreateBooleanValue(true));
+
+  if (!api_permissions.empty()) {
+    AddToExtensionPrefStringSet(
+        extension_id, kPrefGrantedPermissionsAPI, api_permissions);
+  }
+
+  if (!host_extent.is_empty()) {
+    std::set<std::string> host_permissions;
+    ExtentToStringSet(host_extent, &host_permissions);
+
+    AddToExtensionPrefStringSet(
+        extension_id, kPrefGrantedPermissionsHost, host_permissions);
+  }
+
+  SavePrefsAndNotify();
+}
+
 Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const {
   DCHECK(Extension::IdIsValid(extension_id));
   return LastPingDayImpl(GetExtensionPref(extension_id));
 }
 
 Time ExtensionPrefs::BlacklistLastPingDay() const {
   return LastPingDayImpl(prefs_->GetDictionary(kExtensionsBlacklistUpdate));
 }
 
 void ExtensionPrefs::SetLastPingDay(const std::string& extension_id,
@@ skipping 528 matching lines @@
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref);
   prefs->RegisterListPref(kExtensionToolbar);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate);
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList);
   prefs->RegisterStringPref(kWebStoreLogin, std::string() /* default_value */);
 }