Add OAuth2 scopes to the ExtensionPermissionSet and granted permissions.

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/api/alarms/alarm_manager.h"
@@ skipping 106 matching lines @@
 // permissions, for backwards compatibility reasons, and we can still prompt
 // the user to accept them once recognized. We store the active permission
 // permissions because they may differ from those defined in the manifest.
 const char kPrefActivePermissions[] = "active_permissions";
 const char kPrefGrantedPermissions[] = "granted_permissions";
 
 // The preference names for ExtensionPermissionSet values.
 const char kPrefAPIs[] = "api";
 const char kPrefExplicitHosts[] = "explicit_host";
 const char kPrefScriptableHosts[] = "scriptable_host";
+const char kPrefScopes[] = "scopes";
 
 // The preference names for the old granted permissions scheme.
 const char kPrefOldGrantedFullAccess[] = "granted_permissions.full";
 const char kPrefOldGrantedHosts[] = "granted_permissions.host";
 const char kPrefOldGrantedAPIs[] = "granted_permissions.api";
 
 // A preference that indicates when an extension was installed.
 const char kPrefInstallTime[] = "install_time";
 
 // A preference that indicates whether the extension was installed from the
@@ skipping 351 matching lines @@
   ReadExtensionPrefURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefExplicitHosts),
       &explicit_hosts, Extension::kValidHostPermissionSchemes);
 
   // Retrieve the scriptable host permissions.
   URLPatternSet scriptable_hosts;
   ReadExtensionPrefURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefScriptableHosts),
       &scriptable_hosts, UserScript::kValidUserScriptSchemes);
 
-  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+  // Retrieve the oauth2 scopes.
+  ExtensionOAuth2Scopes scopes;
+  const ListValue* scope_values = NULL;
+  std::string scope_pref = JoinPrefs(pref_key, kPrefScopes);
+  if (ReadExtensionPrefList(extension_id, scope_pref, &scope_values)) {
+    for (size_t i = 0; i < scope_values->GetSize(); ++i) {
+      std::string scope;
+      if (scope_values->GetString(i, &scope))
+        scopes.insert(scope);
+    }
+  }
+
+  return new ExtensionPermissionSet(
+      apis, explicit_hosts, scriptable_hosts, scopes);
 }
 
 void ExtensionPrefs::SetExtensionPrefPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key,
     const ExtensionPermissionSet* new_value) {
   // Set the API permissions.
   ListValue* api_values = new ListValue();
   ExtensionAPIPermissionSet apis = new_value->apis();
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
@@ skipping 12 matching lines @@
                                   JoinPrefs(pref_key, kPrefExplicitHosts),
                                   new_value->explicit_hosts());
   }
 
   // Set the scriptable host permissions.
   if (!new_value->scriptable_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefScriptableHosts),
                                   new_value->scriptable_hosts());
   }
+
+  // Set the oauth2 scopes.
+  ExtensionOAuth2Scopes scopes = new_value->scopes();
+  if (!scopes.empty()) {
+    ListValue* scope_values = new ListValue();
+    for (ExtensionOAuth2Scopes::iterator i = scopes.begin();
+         i != scopes.end(); ++i) {
+      scope_values->Append(Value::CreateStringValue(*i));
+    }
+    std::string scope_pref = JoinPrefs(pref_key, kPrefScopes);
+    UpdateExtensionPref(extension_id, scope_pref, scope_values);
+  }
 }
 
 // static
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefBlacklist);
 }
@@ skipping 1304 matching lines @@
   prefs->RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion,
                             "0",  // default value
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
 }