Fix issue that causes some extensions to be disabled right after installation.

chrome/common/extensions/extension_unittest.cc

 // Copyright (c) 2010 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 809 matching lines @@
   EXPECT_TRUE(extension->HasEffectiveAccessToAllHosts());
 }
 
 TEST(ExtensionTest, IsPrivilegeIncrease) {
   const struct {
     const char* base_name;
     // Increase these sizes if you have more than 10.
     const char* granted_apis[10];
     const char* granted_hosts[10];
     bool full_access;
-    bool expect_success;
+    bool expect_increase;
   } kTests[] = {
     { "allhosts1", {NULL}, {"http://*/", NULL}, false,
       false },  // all -> all
     { "allhosts2", {NULL}, {"http://*/", NULL}, false,
       false },  // all -> one
     { "allhosts3", {NULL}, {NULL}, false, true },  // one -> all
     { "hosts1", {NULL},
       {"http://www.google.com/", "http://www.reddit.com/", NULL}, false,
       false },  // http://a,http://b -> http://a,http://b
     { "hosts2", {NULL},
       {"http://www.google.com/", "http://www.reddit.com/", NULL}, false,
-      false },  // http://a,http://b -> https://a,http://*.b
+      true },  // http://a,http://b -> https://a,http://*.b
     { "hosts3", {NULL},
       {"http://www.google.com/", "http://www.reddit.com/", NULL}, false,
       false },  // http://a,http://b -> http://a
     { "hosts4", {NULL},
       {"http://www.google.com/", NULL}, false,
       true },  // http://a -> http://a,http://b
     { "hosts5", {"tabs", "notifications", NULL},
       {"http://*.example.com/", "http://*.example.com/*",
        "http://*.example.co.uk/*", "http://*.example.com.au/*",
        NULL}, false,
@@ skipping 39 matching lines @@
       granted_apis.insert(kTests[i].granted_apis[j]);
 
     ExtensionExtent granted_hosts;
     for (size_t j = 0; kTests[i].granted_hosts[j] != NULL; ++j)
       AddPattern(&granted_hosts, kTests[i].granted_hosts[j]);
 
     EXPECT_TRUE(new_extension.get()) << kTests[i].base_name << "_new.json";
     if (!new_extension.get())
       continue;
 
-    EXPECT_EQ(kTests[i].expect_success,
+    EXPECT_EQ(kTests[i].expect_increase,
               Extension::IsPrivilegeIncrease(kTests[i].full_access,
                                              granted_apis,
                                              granted_hosts,
                                              new_extension.get()))
         << kTests[i].base_name;
   }
 }
 
 TEST(ExtensionTest, PermissionMessages) {
   // Ensure that all permissions that needs to show install UI actually have
@@ skipping 183 matching lines @@
   scoped_refptr<Extension> extension;
   extension = LoadManifest("empty_manifest", "empty.json");
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               extension->HasApiPermission(kTests[i].permission_name))
                   << "Permission being tested: " << kTests[i].permission_name;
   }
 }
 
-TEST(ExtensionTest, GetDistinctHosts) {
+TEST(ExtensionTest, GetDistinctHostsForDisplay) {
   std::vector<std::string> expected;
   expected.push_back("www.foo.com");
   expected.push_back("www.bar.com");
   expected.push_back("www.baz.com");
   URLPatternList actual;
 
   {
     SCOPED_TRACE("no dupes");
 
     // Simple list with no dupes.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHostsForDisplay(actual));
   }
 
   {
     SCOPED_TRACE("two dupes");
 
     // Add some dupes.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHostsForDisplay(actual));
   }
 
   {
     SCOPED_TRACE("schemes differ");
 
     // Add a pattern that differs only by scheme. This should be filtered out.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTPS, "https://www.bar.com/path"));
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHostsForDisplay(actual));
   }
 
   {
     SCOPED_TRACE("paths differ");
 
     // Add some dupes by path.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/pathypath"));
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHostsForDisplay(actual));
   }
 
   {
     SCOPED_TRACE("subdomains differ");
 
     // We don't do anything special for subdomains.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://monkey.www.bar.com/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://bar.com/path"));
 
     expected.push_back("monkey.www.bar.com");
     expected.push_back("bar.com");
 
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHostsForDisplay(actual));
   }
 
   {
     SCOPED_TRACE("RCDs differ");
 
     // Now test for RCD uniquing.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.de/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca.us/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com.my/path"));
 
     // This is an unknown RCD, which shouldn't be uniqued out.
     actual.push_back(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.xyzzy/path"));
 
     expected.push_back("www.foo.xyzzy");
 
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHostsForDisplay(actual));
   }
+
+  {
+    SCOPED_TRACE("wildcards");
+
+    actual.push_back(
+        URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com/*"));
+
+    expected.push_back("*.google.com");
+
+    CompareLists(expected,
+                 Extension::GetDistinctHostsForDisplay(actual));
+  }
+}
+
+TEST(ExtensionTest, IsElevatedHostList) {
+  URLPatternList list1;
+  URLPatternList list2;
+
+  list1.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
+  list1.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
+
+  // Test that the host order does not matter.
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
+
+  EXPECT_FALSE(Extension::IsElevatedHostList(list1, list2));
+  EXPECT_FALSE(Extension::IsElevatedHostList(list2, list1));
+
+  // Test that paths are ignored.
+  list2.clear();
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/*"));
+  EXPECT_FALSE(Extension::IsElevatedHostList(list1, list2));
+  EXPECT_FALSE(Extension::IsElevatedHostList(list2, list1));
+
+  // Test that RCDs are ignored.
+  list2.clear();
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/*"));
+  EXPECT_FALSE(Extension::IsElevatedHostList(list1, list2));
+  EXPECT_FALSE(Extension::IsElevatedHostList(list2, list1));
+
+  // Test that subdomain wildcards are handled properly.
+  list2.clear();
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com.hk/*"));
+  EXPECT_TRUE(Extension::IsElevatedHostList(list1, list2));
+  //TODO(jstritar): Does not match subdomains properly. http://crbug.com/65337
+  //EXPECT_FALSE(Extension::IsElevatedHostList(list2, list1));
+
+  // Test that different domains count as different hosts.
+  list2.clear();
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://www.example.org/path"));
+  EXPECT_TRUE(Extension::IsElevatedHostList(list1, list2));
+  EXPECT_FALSE(Extension::IsElevatedHostList(list2, list1));
+
+  // Test that different subdomains count as different hosts.
+  list2.clear();
+  list2.push_back(
+      URLPattern(URLPattern::SCHEME_HTTP, "http://mail.google.com/*"));
+  EXPECT_TRUE(Extension::IsElevatedHostList(list1, list2));
+  EXPECT_TRUE(Extension::IsElevatedHostList(list2, list1));
 }
 
 TEST(ExtensionTest, GenerateId) {
   std::string result;
   EXPECT_FALSE(Extension::GenerateId("", &result));
 
   EXPECT_TRUE(Extension::GenerateId("test", &result));
   EXPECT_EQ(result, "jpignaibiiemhngfjkcpokkamffknabf");
 
   EXPECT_TRUE(Extension::GenerateId("_", &result));
   EXPECT_EQ(result, "ncocknphbhhlhkikpnnlmbcnbgdempcd");
 
   EXPECT_TRUE(Extension::GenerateId(
       "this_string_is_longer_than_a_single_sha256_hash_digest", &result));
   EXPECT_EQ(result, "jimneklojkjdibfkgiiophfhjhbdgcfi");
 }