Enable permission warnings from ManifestHandlers.

chrome/browser/extensions/extension_prefs_unittest.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/browser/extensions/extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/mock_pref_change_callback.h"
@@ skipping 204 matching lines @@
     AddPattern(&ehost_permissions_, "http://*.google.com/*");
     AddPattern(&ehost_permissions_, "http://example.com/*");
     AddPattern(&ehost_permissions_, "chrome://favicon/*");
     AddPattern(&ehost_permissions_, "https://*.google.com/*");
 
     AddPattern(&shost_permissions_, "http://reddit.com/r/test/*");
     AddPattern(&shost_permissions_, "http://somesite.com/*");
     AddPattern(&shost_permissions_, "http://example.com/*");
 
     APIPermissionSet empty_set;
+    ManifestPermissionSet empty_manifest_permissions;
     URLPatternSet empty_extent;
     scoped_refptr<PermissionSet> permissions;
     scoped_refptr<PermissionSet> granted_permissions;
 
     // Make sure both granted api and host permissions start empty.
     granted_permissions =
         prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(granted_permissions->IsEmpty());
 
     permissions = new PermissionSet(
-        api_perm_set1_, empty_extent, empty_extent);
+        api_perm_set1_, empty_manifest_permissions, empty_extent, empty_extent);
 
     // Add part of the api permissions.
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(granted_permissions.get());
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
     EXPECT_TRUE(granted_permissions->effective_hosts().is_empty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     granted_permissions = NULL;
 
     // Add part of the explicit host permissions.
     permissions = new PermissionSet(
-        empty_set, ehost_perm_set1_, empty_extent);
+        empty_set, empty_manifest_permissions, ehost_perm_set1_, empty_extent);
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
     EXPECT_EQ(ehost_perm_set1_,
               granted_permissions->explicit_hosts());
     EXPECT_EQ(ehost_perm_set1_,
               granted_permissions->effective_hosts());
 
     // Add part of the scriptable host permissions.
     permissions = new PermissionSet(
-        empty_set, empty_extent, shost_perm_set1_);
+        empty_set, empty_manifest_permissions, empty_extent, shost_perm_set1_);
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
     EXPECT_EQ(ehost_perm_set1_,
               granted_permissions->explicit_hosts());
     EXPECT_EQ(shost_perm_set1_,
               granted_permissions->scriptable_hosts());
 
     URLPatternSet::CreateUnion(ehost_perm_set1_, shost_perm_set1_,
                                &effective_permissions_);
     EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
 
     // Add the rest of the permissions.
     permissions = new PermissionSet(
-        api_perm_set2_, ehost_perm_set2_, shost_perm_set2_);
+        api_perm_set2_, empty_manifest_permissions,
+        ehost_perm_set2_, shost_perm_set2_);
 
     APIPermissionSet::Union(expected_apis, api_perm_set2_, &api_permissions_);
 
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(granted_permissions.get());
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_EQ(api_permissions_, granted_permissions->apis());
     EXPECT_EQ(ehost_permissions_,
               granted_permissions->explicit_hosts());
@@ skipping 37 matching lines @@
 class ExtensionPrefsActivePermissions : public ExtensionPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
     APIPermissionSet api_perms;
     api_perms.insert(APIPermission::kTab);
     api_perms.insert(APIPermission::kBookmark);
     api_perms.insert(APIPermission::kHistory);
 
+    ManifestPermissionSet empty_manifest_permissions;
+
     URLPatternSet ehosts;
     AddPattern(&ehosts, "http://*.google.com/*");
     AddPattern(&ehosts, "http://example.com/*");
     AddPattern(&ehosts, "chrome://favicon/*");
 
     URLPatternSet shosts;
     AddPattern(&shosts, "https://*.google.com/*");
     AddPattern(&shosts, "http://reddit.com/r/test/*");
 
-    active_perms_ = new PermissionSet(api_perms, ehosts, shosts);
+    active_perms_ = new PermissionSet(
+        api_perms, empty_manifest_permissions, ehosts, shosts);
 
     // Make sure the active permissions start empty.
     scoped_refptr<PermissionSet> active(
         prefs()->GetActivePermissions(extension_id_));
     EXPECT_TRUE(active->IsEmpty());
 
     // Set the active permissions.
     prefs()->SetActivePermissions(extension_id_, active_perms_.get());
     active = prefs()->GetActivePermissions(extension_id_);
     EXPECT_EQ(active_perms_->apis(), active->apis());
@@ skipping 474 matching lines @@
 
  private:
   scoped_refptr<const Extension> extension_a_;
   scoped_refptr<const Extension> extension_b_;
   scoped_refptr<const Extension> extension_c_;
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 }  // namespace extensions