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 1087 matching lines @@
 
   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) {
   std::vector<std::string> expected;
+  std::vector<std::string> expected_no_rcd;
   expected.push_back("www.foo.com");
   expected.push_back("www.bar.com");
   expected.push_back("www.baz.com");
+  expected_no_rcd.push_back("www.foo.");
+  expected_no_rcd.push_back("www.bar.");
+  expected_no_rcd.push_back("www.baz.");
   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::GetDistinctHosts(actual, true));
+    CompareLists(expected_no_rcd,
+                 Extension::GetDistinctHosts(actual, false));
   }
 
   {
     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::GetDistinctHosts(actual, true));
+    CompareLists(expected_no_rcd,
+                 Extension::GetDistinctHosts(actual, false));
   }
 
   {
     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::GetDistinctHosts(actual, true));
+    CompareLists(expected_no_rcd,
+                 Extension::GetDistinctHosts(actual, false));
   }
 
   {
     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::GetDistinctHosts(actual, true));
+    CompareLists(expected_no_rcd,
+                 Extension::GetDistinctHosts(actual, false));
   }
 
   {
     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");
+    expected_no_rcd.push_back("monkey.www.bar.");
+    expected_no_rcd.push_back("bar.");
+
 
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHosts(actual, true));
+    CompareLists(expected_no_rcd,
+                 Extension::GetDistinctHosts(actual, false));
   }
 
   {
     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");
+    expected_no_rcd.push_back("www.foo.xyzzy");
 
     CompareLists(expected,
-                 Extension::GetDistinctHosts(actual));
+                 Extension::GetDistinctHosts(actual, true));
+    CompareLists(expected_no_rcd,
+                 Extension::GetDistinctHosts(actual, false));
   }
 }
 
 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");
 }