Support socket endpoint permissions for AppsV2 Socket API.

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 3319 matching lines @@
   if (manifest_->HasKey(key)) {
     ListValue* permissions = NULL;
     if (!manifest_->GetList(key, &permissions)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     for (size_t i = 0; i < permissions->GetSize(); ++i) {
       std::string permission_str;
+      const base::Value* permission_detail = NULL;
       if (!permissions->GetString(i, &permission_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidPermission, base::IntToString(i));
-        return false;
+        const base::DictionaryValue *dict = NULL;
+        // permission should be a string or a single key dict.
+        if (!permissions->GetDictionary(i, &dict) || dict->size() != 1) {
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+              errors::kInvalidPermission, base::IntToString(i));
+          return false;
+        }
+        base::DictionaryValue::Iterator it(*dict);
+        permission_str = it.key();
+        permission_detail = &it.value();
       }
 
       // NOTE: We need to get the APIPermission before the Feature
       // object because the feature system does not know about aliases.
       APIPermission* permission =
           PermissionsInfo::GetInstance()->GetByName(permission_str);
       if (permission) {
         extensions::SimpleFeatureProvider* permission_features =
             extensions::SimpleFeatureProvider::GetPermissionFeatures();
         extensions::Feature* feature =
@@ skipping 20 matching lines @@
           continue;
         }
 
         if (permission->id() == APIPermission::kExperimental) {
           if (!CanSpecifyExperimentalPermission()) {
             *error = ASCIIToUTF16(errors::kExperimentalFlagRequired);
             return false;
           }
         }
 
-        api_permissions->insert(permission->id());
+        scoped_refptr<APIPermissionDetail> detail = permission->CreateDetail();
+        if (!detail->FromValue(permission_detail)) {
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+              errors::kInvalidPermission, base::IntToString(i));
+          return false;
+        }
+
+        api_permissions->insert(detail);
         continue;
       }
 
       // Check if it's a host pattern permission.
       const int kAllowedSchemes = CanExecuteScriptEverywhere() ?
           URLPattern::SCHEME_ALL : kValidHostPermissionSchemes;
 
       URLPattern pattern = URLPattern(kAllowedSchemes);
       URLPattern::ParseResult parse_result = pattern.Parse(permission_str);
       if (parse_result == URLPattern::PARSE_SUCCESS) {
@@ skipping 76 matching lines @@
                                        APIPermission::ID permission) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   if (runtime_data_.GetActivePermissions()->HasAPIPermission(permission))
     return true;
   scoped_refptr<const PermissionSet> tab_specific_permissions =
       runtime_data_.GetTabSpecificPermissions(tab_id);
   return tab_specific_permissions.get() &&
          tab_specific_permissions->HasAPIPermission(permission);
 }
 
+bool Extension::CheckAPIPermissionWithDetail(APIPermission::ID permission,
+    const APIPermissionDetail::CheckParam* param) const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions()->
+      CheckAPIPermissionWithDetail(permission, param);
+}
+
 const URLPatternSet& Extension::GetEffectiveHostPermissions() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->effective_hosts();
 }
 
 bool Extension::HasHostPermission(const GURL& url) const {
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() != chrome::kChromeUIFaviconHost &&
       url.host() != chrome::kChromeUIThumbnailHost &&
       location() != Extension::COMPONENT) {
@@ skipping 412 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions