Restrict access to permissions based on extension types.

chrome/common/extensions/extension_manifests_unittest.cc

 // Copyright (c) 2011 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"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 611 matching lines @@
 }
 
 TEST_F(ExtensionManifestTest, HostedAppPermissions) {
   std::string error;
   scoped_ptr<DictionaryValue> manifest(
       LoadManifestFile("hosted_app_absolute_options.json", &error));
   ASSERT_TRUE(manifest.get());
   ListValue* permissions = NULL;
   ASSERT_TRUE(manifest->GetList("permissions", &permissions));
 
+  int platform_app = ExtensionAPIPermission::kTypePlatformApp;
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet api_perms = info->GetAll();
   for (ExtensionAPIPermissionSet::iterator i = api_perms.begin();
        i != api_perms.end(); ++i) {
     if (*i == ExtensionAPIPermission::kExperimental)
       continue;
 
     ExtensionAPIPermission* permission = info->GetByID(*i);
     const char* name = permission->name();
     StringValue* p = new StringValue(name);
     permissions->Clear();
     permissions->Append(p);
 
     // Some permissions are only available to component hosted apps.
     if (permission->is_component_only()) {
       LoadAndExpectError(Manifest(manifest.get(), name),
                          errors::kPermissionNotAllowed,
                          Extension::INTERNAL);
       scoped_refptr<Extension> extension(
           LoadAndExpectSuccess(Manifest(manifest.get(), name),
                                Extension::COMPONENT));
       EXPECT_TRUE(extension->GetActivePermissions()->HasAPIPermission(
           permission->id()));
 
-    } else if (permission->is_platform_app_only()) {
+    } else if (permission->type_restrictions() == platform_app) {
       LoadAndExpectError(Manifest(manifest.get(), name),
                          errors::kPermissionNotAllowed,
                          Extension::INTERNAL,
                          Extension::STRICT_ERROR_CHECKS);
-    } else if (!permission->is_hosted_app()) {
+    } else if (!permission->supports_hosted_apps()) {
       // Most normal extension permissions also aren't available to hosted apps.
       // For these, the error is only reported in strict mode for legacy
       // reasons: crbug.com/101993.
       LoadAndExpectError(Manifest(manifest.get(), name),
                          errors::kPermissionNotAllowed,
                          Extension::INTERNAL,
                          Extension::STRICT_ERROR_CHECKS);
       scoped_refptr<Extension> extension(
           LoadAndExpectSuccess(Manifest(manifest.get(), name),
                                Extension::INTERNAL));
@@ skipping 295 matching lines @@
   EXPECT_TRUE(extension_4->offline_enabled());
 }
 
 TEST_F(ExtensionManifestTest, PlatformAppOnlyPermissions) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet private_perms;
   private_perms.insert(ExtensionAPIPermission::kSocket);
 
   ExtensionAPIPermissionSet perms = info->GetAll();
   int count = 0;
+  int platform_app = ExtensionAPIPermission::kTypePlatformApp;
   for (ExtensionAPIPermissionSet::iterator i = perms.begin();
        i != perms.end(); ++i) {
     count += private_perms.count(*i);
     EXPECT_EQ(private_perms.count(*i) > 0,
-              info->GetByID(*i)->is_platform_app_only());
+              info->GetByID(*i)->type_restrictions() == platform_app);
   }
   EXPECT_EQ(1, count);
 
   // This guy should fail to load because he's requesting platform-app-only
   // permissions.
   LoadAndExpectError("evil_non_platform_app.json",
                      errors::kPermissionNotAllowed,
                      Extension::INTERNAL, Extension::STRICT_ERROR_CHECKS);
 
   // This guy is identical to the previous but doesn't ask for any
   // platform-app-only permissions. We should be able to load him and ask
   // questions about his permissions.
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("not_platform_app.json"));
-  scoped_refptr<const ExtensionPermissionSet> permissions;
-  permissions = extension->GetActivePermissions();
-  EXPECT_FALSE(permissions->HasPlatformAppPermissions());
+  ExtensionAPIPermissionSet apis = extension->GetActivePermissions()->apis();
+  for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
+       i != apis.end(); ++i)
+    EXPECT_NE(platform_app, info->GetByID(*i)->type_restrictions());
 }