Start refractoring extension permissions into ExtensionPermissionSet.

chrome/browser/extensions/extension_prefs_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 "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #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"
 #include "content/common/notification_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
 const char kPref1[] = "path1.subpath";
 const char kPref2[] = "path2";
 const char kPref3[] = "path3";
 const char kPref4[] = "path4";
 
 // Default values in case an extension pref value is not overridden.
 const char kDefaultPref1[] = "default pref 1";
 const char kDefaultPref2[] = "default pref 2";
 const char kDefaultPref3[] = "default pref 3";
 const char kDefaultPref4[] = "default pref 4";
 
 }  // namespace
 
 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 137 matching lines @@
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsEscalatePermissions, EscalatePermissions) {}
 
 // Tests the AddGrantedPermissions / GetGrantedPermissions functions.
 class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
  public:
   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/*");
     AddPattern(&host_perm_set1_, "chrome://favicon/*");
 
     AddPattern(&host_perm_set2_, "https://*.google.com/*");
     // with duplicate:
     AddPattern(&host_perm_set2_, "http://*.google.com/*");
 
     std::set_union(api_perm_set1_.begin(), api_perm_set1_.end(),
                    api_perm_set2_.begin(), api_perm_set2_.end(),
                    std::inserter(api_permissions_, api_permissions_.begin()));
 
     AddPattern(&host_permissions_, "http://*.google.com/*");
     AddPattern(&host_permissions_, "http://example.com/*");
     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) {}
 
 // Tests the GetVersionString function.
 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     extension = prefs_.AddExtension("test");
     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
@@ skipping 690 matching lines @@
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
   virtual void Verify() {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}