Support socket endpoint permissions for AppsV2 Socket API.

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 477 matching lines @@
     const URLPatternSet& new_value) {
   UpdateExtensionPref(extension_id, pref_key, new_value.ToValue().release());
 }
 
 PermissionSet* ExtensionPrefs::ReadExtensionPrefPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key) {
   if (!GetExtensionPref(extension_id))
     return NULL;
 
-  // Retrieve the API permissions.
+  // Retrieve the API permissions. Please refer SetExtensionPrefPermissionSet()
+  // for api_values format.
   APIPermissionSet apis;
   const ListValue* api_values = NULL;
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   if (ReadExtensionPrefList(extension_id, api_pref, &api_values)) {
     PermissionsInfo* info = PermissionsInfo::GetInstance();
     for (size_t i = 0; i < api_values->GetSize(); ++i) {
+      const ListValue* permission_list = NULL;
       std::string permission_name;
-      if (api_values->GetString(i, &permission_name)) {
+      if (api_values->GetString(i, &permission_name) ||
+          (api_values->GetList(i, &permission_list) &&
+           permission_list->GetString(0, &permission_name))) {
         APIPermission *permission = info->GetByName(permission_name);
-        if (permission)
-          apis.insert(permission->id());
+        if (permission) {
+          const Value* tmp = NULL;
+          scoped_refptr<APIPermissionDetail> detail =
+            permission->CreateDetail();
+          if (permission_list) {
+            if (permission_list->Get(1, &tmp))
+              detail->FromValue(tmp);
+            else
+              DLOG(WARNING) << "Get detail from permission_list failed.";
+          }
+          apis.insert(detail);
+        }
       }
     }
   }
 
   // Retrieve the explicit host permissions.
   URLPatternSet explicit_hosts;
   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 PermissionSet(apis, explicit_hosts, scriptable_hosts);
 }
 
 void ExtensionPrefs::SetExtensionPrefPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key,
     const PermissionSet* new_value) {
   // Set the API permissions.
+  // The format of api_values is:
+  // [ "permission_name1",   // permissions do not support detail.
+  //   "permission_name2",
+  //   [ "permission_name3", value ],
+  //   // permission supports detail, permission detail will be stored in value.
+  //   ...
+  // ]
   ListValue* api_values = new ListValue();
   APIPermissionSet apis = new_value->apis();
-  PermissionsInfo* info = PermissionsInfo::GetInstance();
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   for (APIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
-    APIPermission* perm = info->GetByID(*i);
-    if (perm)
-      api_values->Append(Value::CreateStringValue(perm->name()));
+    Value* detail = NULL;
+    i->ToValue(&detail);
+    if (!detail) {
+      api_values->Append(Value::CreateStringValue(i->name()));
+    } else {
+      ListValue* tmp = new ListValue();
+      tmp->Append(Value::CreateStringValue(i->name()));
+      tmp->Append(detail);
+      api_values->Append(tmp);
+    }
   }
   UpdateExtensionPref(extension_id, api_pref, api_values);
 
   // Set the explicit host permissions.
   if (!new_value->explicit_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefExplicitHosts),
                                   new_value->explicit_hosts());
   }
 
@@ skipping 1545 matching lines @@
                                                 const ExtensionIdSet& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
   for (ExtensionIdSet::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter)
     list_of_values->Append(new StringValue(*iter));
 }
 
 }  // namespace extensions