Start refractoring extension permissions into ExtensionPermissionSet.

chrome/browser/extensions/extension_prefs_unittest.cc

Index: chrome/browser/extensions/extension_prefs_unittest.cc
diff --git a/chrome/browser/extensions/extension_prefs_unittest.cc b/chrome/browser/extensions/extension_prefs_unittest.cc
index 673044a4a189d8dcf76a7cd7ef769713e7a7e4dd..57e0cf41ee4dd4805eeb66be9b65923aa1e80d1c 100644
--- a/chrome/browser/extensions/extension_prefs_unittest.cc
+++ b/chrome/browser/extensions/extension_prefs_unittest.cc
@@ -14,6 +14,7 @@
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/extension_permission_set.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_observer_mock.h"
@@ -43,10 +44,10 @@ static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   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());
 
@@ -204,12 +205,10 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
   virtual void Initialize() {
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
-    api_perm_set1_.insert("tabs");
-    api_perm_set1_.insert("bookmarks");
-    api_perm_set1_.insert("something_random");
+    api_perm_set1_.insert(ExtensionAPIPermission::Tab());
+    api_perm_set1_.insert(ExtensionAPIPermission::Bookmark());
 
-    api_perm_set2_.insert("history");
-    api_perm_set2_.insert("unknown2");
+    api_perm_set2_.insert(ExtensionAPIPermission::History());
 
     AddPattern(&host_perm_set1_, "http://*.google.com/*");
     AddPattern(&host_perm_set1_, "http://example.com/*");
@@ -228,75 +227,78 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
     AddPattern(&host_permissions_, "chrome://favicon/*");
     AddPattern(&host_permissions_, "https://*.google.com/*");
 
-    std::set<std::string> empty_set;
-    std::set<std::string> api_perms;
-    bool full_access = false;
-    URLPatternSet host_perms;
+    std::set<ExtensionAPIPermission> empty_set;
     URLPatternSet empty_extent;
+    scoped_ptr<ExtensionPermissionSet> permissions;
+    scoped_ptr<ExtensionPermissionSet> granted_permissions;
 
     // Make sure both granted api and host permissions start empty.
-    EXPECT_FALSE(prefs()->GetGrantedPermissions(
-        extension_id_, &full_access, &api_perms, &host_perms));
-
-    EXPECT_TRUE(api_perms.empty());
-    EXPECT_TRUE(host_perms.is_empty());
+    bool initialized = false;
+    granted_permissions.reset(
+        prefs()->GetGrantedPermissions(extension_id_, &initialized));
+    EXPECT_TRUE(granted_permissions.get());
+    EXPECT_FALSE(initialized);
+    EXPECT_TRUE(granted_permissions->IsEmpty());
+    permissions.reset(
+        new ExtensionPermissionSet(false, api_perm_set1_, empty_extent));
 
     // Add part of the api permissions.
-    prefs()->AddGrantedPermissions(
-        extension_id_, false, api_perm_set1_, empty_extent);
-    EXPECT_TRUE(prefs()->GetGrantedPermissions(
-        extension_id_, &full_access, &api_perms, &host_perms));
-    EXPECT_EQ(api_perm_set1_, api_perms);
-    EXPECT_TRUE(host_perms.is_empty());
-    EXPECT_FALSE(full_access);
-    host_perms.ClearPatterns();
-    api_perms.clear();
+    prefs()->AddGrantedPermissions(extension_id_, *permissions);
+    granted_permissions.reset(
+        prefs()->GetGrantedPermissions(extension_id_, &initialized));
+    EXPECT_FALSE(granted_permissions->IsEmpty());
+    EXPECT_TRUE(initialized);
+    EXPECT_EQ(api_perm_set1_, granted_permissions->apis());
+    EXPECT_TRUE(granted_permissions->effective_hosts().is_empty());
+    EXPECT_FALSE(granted_permissions->native_code());
+    granted_permissions.reset();
 
     // Add part of the host permissions.
-    prefs()->AddGrantedPermissions(
-        extension_id_, false, empty_set, host_perm_set1_);
-    EXPECT_TRUE(prefs()->GetGrantedPermissions(
-        extension_id_, &full_access, &api_perms, &host_perms));
-    EXPECT_FALSE(full_access);
-    EXPECT_EQ(api_perm_set1_, api_perms);
-    AssertEqualExtents(&host_perm_set1_, &host_perms);
-    host_perms.ClearPatterns();
-    api_perms.clear();
+    permissions.reset(
+        new ExtensionPermissionSet(false, empty_set, host_perm_set1_));
+    prefs()->AddGrantedPermissions(extension_id_, *permissions);
+
+    // Make sure we can pass NULL in for initialized.
+    granted_permissions.reset(
+        prefs()->GetGrantedPermissions(extension_id_, NULL));
+    EXPECT_FALSE(granted_permissions->IsEmpty());
+    EXPECT_FALSE(granted_permissions->native_code());
+    EXPECT_EQ(api_perm_set1_, granted_permissions->apis());
+    AssertEqualExtents(host_perm_set1_, granted_permissions->effective_hosts());
 
     // Add the rest of both the api and host permissions.
-    prefs()->AddGrantedPermissions(extension_id_,
-                                   true,
-                                   api_perm_set2_,
-                                   host_perm_set2_);
-
-    EXPECT_TRUE(prefs()->GetGrantedPermissions(
-        extension_id_, &full_access, &api_perms, &host_perms));
-    EXPECT_TRUE(full_access);
-    EXPECT_EQ(api_permissions_, api_perms);
-    AssertEqualExtents(&host_permissions_, &host_perms);
+    permissions.reset(
+        new ExtensionPermissionSet(true, api_perm_set2_, host_perm_set2_));
+    prefs()->AddGrantedPermissions(extension_id_, *permissions);
+    initialized = false;
+    granted_permissions.reset(
+        prefs()->GetGrantedPermissions(extension_id_, &initialized));
+    EXPECT_FALSE(granted_permissions->IsEmpty());
+    EXPECT_TRUE(initialized);
+    EXPECT_TRUE(granted_permissions->native_code());
+    EXPECT_EQ(api_permissions_, granted_permissions->apis());
+    AssertEqualExtents(host_permissions_,
+                       granted_permissions->effective_hosts());
   }
 
   virtual void Verify() {
-    std::set<std::string> api_perms;
-    URLPatternSet host_perms;
-    bool full_access;
-
-    EXPECT_TRUE(prefs()->GetGrantedPermissions(
-        extension_id_, &full_access, &api_perms, &host_perms));
-    EXPECT_EQ(api_permissions_, api_perms);
-    EXPECT_TRUE(full_access);
-    AssertEqualExtents(&host_permissions_, &host_perms);
+    bool initialized = false;
+    scoped_ptr<ExtensionPermissionSet> permissions(
+        prefs()->GetGrantedPermissions(extension_id_, &initialized));
+    EXPECT_TRUE(initialized);
+    EXPECT_EQ(api_permissions_, permissions->apis());
+    EXPECT_TRUE(permissions->native_code());
+    AssertEqualExtents(host_permissions_, permissions->effective_hosts());
   }
 
  private:
   std::string extension_id_;
-  std::set<std::string> api_perm_set1_;
-  std::set<std::string> api_perm_set2_;
+  std::set<ExtensionAPIPermission> api_perm_set1_;
+  std::set<ExtensionAPIPermission> api_perm_set2_;
   URLPatternSet host_perm_set1_;
   URLPatternSet host_perm_set2_;
 
-
-  std::set<std::string> api_permissions_;
+  std::set<ExtensionAPIPermission> api_permissions_;
   URLPatternSet host_permissions_;
 };
 TEST_F(ExtensionPrefsGrantedPermissions, GrantedPermissions) {}