Start refractoring extension permissions into ExtensionPermissionSet.

chrome/browser/extensions/extension_service_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/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 96 matching lines @@
   std::stable_sort(ret_val.begin(), ret_val.end());
 
   return ret_val;
 }
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
-static void AssertEqualExtents(URLPatternSet* extent1,
-                               URLPatternSet* extent2) {
-  URLPatternList patterns1 = extent1->patterns();
-  URLPatternList patterns2 = extent2->patterns();
+static void AssertEqualExtents(const URLPatternSet& extent1,
+                               const URLPatternSet& extent2) {
+  URLPatternList patterns1 = extent1.patterns();
+  URLPatternList patterns2 = extent2.patterns();
   std::set<std::string> strings1;
   EXPECT_EQ(patterns1.size(), patterns2.size());
 
   for (size_t i = 0; i < patterns1.size(); ++i)
     strings1.insert(patterns1.at(i).GetAsString());
 
   std::set<std::string> strings2;
   for (size_t i = 0; i < patterns2.size(); ++i)
     strings2.insert(patterns2.at(i).GetAsString());
 
@@ skipping 1234 matching lines @@
 
   FilePath pem_path = path.AppendASCII("unknown.pem");
   path = path.AppendASCII("unknown");
 
   ASSERT_TRUE(file_util::PathExists(pem_path));
   ASSERT_TRUE(file_util::PathExists(path));
 
   ExtensionPrefs* prefs = service_->extension_prefs();
 
   std::set<std::string> expected_api_perms;
-  std::set<std::string> known_api_perms;
-  bool full_access;
   URLPatternSet expected_host_perms;
-  URLPatternSet known_host_perms;
+  bool initialized = false;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
-  EXPECT_FALSE(prefs->GetGrantedPermissions(
-      permissions_crx, &full_access, &known_api_perms, &known_host_perms));
-  EXPECT_TRUE(known_api_perms.empty());
-  EXPECT_TRUE(known_host_perms.is_empty());
+  scoped_ptr<ExtensionPermissionSet> known_perms(
+      prefs->GetGrantedPermissions(permissions_crx, &initialized));
+  EXPECT_FALSE(initialized);
+  EXPECT_TRUE(known_perms->IsEmpty());
 
   PackAndInstallCrx(path, pem_path, true);
 
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, service_->extensions()->size());
   std::string extension_id = service_->extensions()->at(0)->id();
   EXPECT_EQ(permissions_crx, extension_id);
 
-
   // Verify that the valid API permissions have been recognized.
   expected_api_perms.insert("tabs");
 
   AddPattern(&expected_host_perms, "http://*.google.com/*");
   AddPattern(&expected_host_perms, "https://*.google.com/*");
   AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
   AddPattern(&expected_host_perms, "http://www.example.com/*");
 
-  EXPECT_TRUE(prefs->GetGrantedPermissions(extension_id,
-                                           &full_access,
-                                           &known_api_perms,
-                                           &known_host_perms));
-
-  EXPECT_EQ(expected_api_perms, known_api_perms);
-  EXPECT_FALSE(full_access);
-  AssertEqualExtents(&expected_host_perms, &known_host_perms);
+  known_perms.reset(prefs->GetGrantedPermissions(extension_id, &initialized));
+  EXPECT_TRUE(initialized);
+  EXPECT_FALSE(known_perms->IsEmpty());
+  EXPECT_EQ(ExtensionAPIPermission::GetAllByName(expected_api_perms),
+            known_perms->apis());
+  EXPECT_FALSE(known_perms->native_code());
+  AssertEqualExtents(expected_host_perms, known_perms->effective_hosts());
 }
 
 #if !defined(OS_CHROMEOS)
 // Tests that the granted permissions full_access bit gets set correctly when
 // an extension contains an NPAPI plugin. Don't run this test on Chrome OS
 // since they don't support plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good1)
       .AppendASCII("2");
 
   ASSERT_TRUE(file_util::PathExists(path));
 
   PackAndInstallCrx(path, true);
 
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, service_->extensions()->size());
   const Extension* extension = service_->extensions()->at(0);
   std::string extension_id = extension->id();
   ExtensionPrefs* prefs = service_->extension_prefs();
 
-  bool full_access;
-  std::set<std::string> api_permissions;
-  URLPatternSet host_permissions;
-  EXPECT_TRUE(prefs->GetGrantedPermissions(
-      extension_id, &full_access, &api_permissions, &host_permissions));
-
-  EXPECT_TRUE(full_access);
-  EXPECT_TRUE(api_permissions.empty());
-  EXPECT_TRUE(host_permissions.is_empty());
+  scoped_ptr<ExtensionPermissionSet> permissions(
+      prefs->GetGrantedPermissions(extension_id, NULL));
+  EXPECT_FALSE(permissions->IsEmpty());
+  EXPECT_TRUE(permissions->native_code());
+  EXPECT_TRUE(permissions->apis().empty());
+  EXPECT_TRUE(permissions->effective_hosts().is_empty());
 }
 #endif
 
 // Tests that the extension is disabled when permissions are missing from
 // the extension's granted permissions preferences. (This simulates updating
 // the browser to a version which recognizes more permissions).
 TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_
       .AppendASCII("permissions")
       .AppendASCII("unknown");
 
   ASSERT_TRUE(file_util::PathExists(path));
 
   PackAndInstallCrx(path, true);
 
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, service_->extensions()->size());
   const Extension* extension = service_->extensions()->at(0);
   std::string extension_id = extension->id();
 
   ExtensionPrefs* prefs = service_->extension_prefs();
 
   std::set<std::string> expected_api_permissions;
   URLPatternSet expected_host_permissions;
+  bool initialized = false;
 
   expected_api_permissions.insert("tabs");
   AddPattern(&expected_host_permissions, "http://*.google.com/*");
   AddPattern(&expected_host_permissions, "https://*.google.com/*");
   AddPattern(&expected_host_permissions, "http://*.google.com.hk/*");
   AddPattern(&expected_host_permissions, "http://www.example.com/*");
 
   std::set<std::string> api_permissions;
   std::set<std::string> host_permissions;
 
   // Test that the extension is disabled when an API permission is missing from
   // the extension's granted api permissions preference. (This simulates
   // updating the browser to a version which recognizes a new API permission).
   SetPrefStringSet(extension_id, "granted_permissions.api", api_permissions);
 
   service_->ReloadExtensions();
 
   EXPECT_EQ(1u, service_->disabled_extensions()->size());
   extension = service_->disabled_extensions()->at(0);
 
   ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::DISABLED);
   ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
 
   // Now grant and re-enable the extension, making sure the prefs are updated.
   service_->GrantPermissionsAndEnableExtension(extension);
 
   ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::ENABLED);
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
-  std::set<std::string> current_api_permissions;
-  URLPatternSet current_host_permissions;
-  bool current_full_access;
-
-  ASSERT_TRUE(prefs->GetGrantedPermissions(extension_id,
-                                           &current_full_access,
-                                           &current_api_permissions,
-                                           &current_host_permissions));
-
-  ASSERT_FALSE(current_full_access);
-  ASSERT_EQ(expected_api_permissions, current_api_permissions);
-  AssertEqualExtents(&expected_host_permissions, &current_host_permissions);
+  scoped_ptr<ExtensionPermissionSet> current_perms(
+      prefs->GetGrantedPermissions(extension_id, &initialized));
+  ASSERT_FALSE(current_perms->IsEmpty());
+  ASSERT_TRUE(initialized);
+  ASSERT_FALSE(current_perms->native_code());
+  ASSERT_EQ(ExtensionAPIPermission::GetAllByName(expected_api_permissions),
+            current_perms->apis());
+  AssertEqualExtents(expected_host_permissions,
+                     current_perms->effective_hosts());
 
   // Tests that the extension is disabled when a host permission is missing from
   // the extension's granted host permissions preference. (This simulates
   // updating the browser to a version which recognizes additional host
   // permissions).
   api_permissions.clear();
   host_permissions.clear();
-  current_api_permissions.clear();
-  current_host_permissions.ClearPatterns();
+  current_perms.reset();
 
   api_permissions.insert("tabs");
   host_permissions.insert("http://*.google.com/*");
   host_permissions.insert("https://*.google.com/*");
   host_permissions.insert("http://*.google.com.hk/*");
 
   SetPrefStringSet(extension_id, "granted_permissions.api", api_permissions);
   SetPrefStringSet(extension_id, "granted_permissions.host", host_permissions);
 
   service_->ReloadExtensions();
 
   EXPECT_EQ(1u, service_->disabled_extensions()->size());
   extension = service_->disabled_extensions()->at(0);
 
   ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::DISABLED);
   ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
 
   // Now grant and re-enable the extension, making sure the prefs are updated.
   service_->GrantPermissionsAndEnableExtension(extension);
 
   ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::ENABLED);
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
-  ASSERT_TRUE(prefs->GetGrantedPermissions(extension_id,
-                                           &current_full_access,
-                                           &current_api_permissions,
-                                           &current_host_permissions));
-
-  ASSERT_FALSE(current_full_access);
-  ASSERT_EQ(expected_api_permissions, current_api_permissions);
-  AssertEqualExtents(&expected_host_permissions, &current_host_permissions);
+  current_perms.reset(
+      prefs->GetGrantedPermissions(extension_id, &initialized));
+  ASSERT_TRUE(initialized);
+  ASSERT_FALSE(current_perms->IsEmpty());
+  ASSERT_FALSE(current_perms->native_code());
+  ASSERT_EQ(ExtensionAPIPermission::GetAllByName(expected_api_permissions),
+            current_perms->apis());
+  AssertEqualExtents(expected_host_permissions,
+                     current_perms->effective_hosts());
 
   // Tests that the granted permissions preferences are initialized when
   // migrating from the old pref schema.
-  current_api_permissions.clear();
-  current_host_permissions.ClearPatterns();
+  current_perms.reset();
 
   ClearPref(extension_id, "granted_permissions");
 
   service_->ReloadExtensions();
 
   EXPECT_EQ(1u, service_->extensions()->size());
   extension = service_->extensions()->at(0);
 
   ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::ENABLED);
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
-  ASSERT_TRUE(prefs->GetGrantedPermissions(extension_id,
-                                           &current_full_access,
-                                           &current_api_permissions,
-                                           &current_host_permissions));
-
-  ASSERT_FALSE(current_full_access);
-  ASSERT_EQ(expected_api_permissions, current_api_permissions);
-  AssertEqualExtents(&expected_host_permissions, &current_host_permissions);
+  current_perms.reset(prefs->GetGrantedPermissions(extension_id, NULL));
+  ASSERT_FALSE(current_perms->IsEmpty());
+  ASSERT_FALSE(current_perms->native_code());
+  ASSERT_EQ(ExtensionAPIPermission::GetAllByName(expected_api_permissions),
+            current_perms->apis());
+  AssertEqualExtents(expected_host_permissions,
+                     current_perms->effective_hosts());
 }
 
 // Test Packaging and installing an extension.
 TEST_F(ExtensionServiceTest, PackExtension) {
   InitializeEmptyExtensionService();
   FilePath input_directory = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
@@ skipping 242 matching lines @@
 
   int pref_count = 0;
 
   // Install app1 with unlimited storage.
   PackAndInstallCrx(data_dir_.AppendASCII("app1"), true);
   ValidatePrefKeyCount(++pref_count);
   ASSERT_EQ(1u, service_->extensions()->size());
   const Extension* extension = service_->extensions()->at(0);
   const std::string id1 = extension->id();
   EXPECT_TRUE(extension->HasApiPermission(
-                  Extension::kUnlimitedStoragePermission));
+      ExtensionAPIPermission::UnlimitedStorage()));
   EXPECT_TRUE(extension->web_extent().MatchesURL(
                   extension->GetFullLaunchURL()));
   const GURL origin1(extension->GetFullLaunchURL().GetOrigin());
   EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
       IsStorageUnlimited(origin1));
 
   // Install app2 from the same origin with unlimited storage.
   PackAndInstallCrx(data_dir_.AppendASCII("app2"), true);
   ValidatePrefKeyCount(++pref_count);
   ASSERT_EQ(2u, service_->extensions()->size());
   extension = service_->extensions()->at(1);
   const std::string id2 = extension->id();
   EXPECT_TRUE(extension->HasApiPermission(
-                  Extension::kUnlimitedStoragePermission));
+      ExtensionAPIPermission::UnlimitedStorage()));
   EXPECT_TRUE(extension->web_extent().MatchesURL(
                   extension->GetFullLaunchURL()));
   const GURL origin2(extension->GetFullLaunchURL().GetOrigin());
   EXPECT_EQ(origin1, origin2);
   EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
       IsStorageUnlimited(origin2));
 
 
   // Uninstall one of them, unlimited storage should still be granted
   // to the origin.
@@ skipping 1937 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }