Fix parsing of effective TLD wildcarding across IPC.

extensions/common/extension_messages_unittest.cc

 // Copyright 2016 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 "components/crx_file/id_util.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/permissions_parser.h"
 #include "extensions/common/permissions/extensions_api_permissions.h"
@@ skipping 16 matching lines @@
   EXPECT_TRUE(extension1.manifest()->Equals(extension2.manifest()));
   const PermissionsData::TabPermissionsMap& second_tab_permissions =
       extension2.permissions_data()->tab_specific_permissions();
   for (const auto& tab_permissions :
        extension1.permissions_data()->tab_specific_permissions()) {
     ASSERT_NE(0u, second_tab_permissions.count(tab_permissions.first));
     EXPECT_EQ(*tab_permissions.second,
               *(second_tab_permissions.at(tab_permissions.first)))
         << tab_permissions.first;
   }
+  EXPECT_EQ(extension1.permissions_data()->policy_blocked_hosts(),
+            extension2.permissions_data()->policy_blocked_hosts());
+  EXPECT_EQ(extension1.permissions_data()->policy_allowed_hosts(),
+            extension2.permissions_data()->policy_allowed_hosts());
+}
+
+static void AddPattern(URLPatternSet* extent, const std::string& pattern) {

[lazyboy, 2017/06/30 20:43:22]

nit: since this is already in anonymous namespace, remove "static"
Also pattern parameter comes before extent as |extent| is output parameter.

[nrpeter, 2017/06/30 21:22:15]

Done.

+  URLPattern parsed(URLPattern::SCHEME_ALL);
+  parsed.Parse(pattern, URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD);
+  extent->AddPattern(parsed);
 }
 
 }  // namespace
 
 TEST(ExtensionMessageTypesTest, TestLoadedParams) {
   std::unique_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", "extension")
           .Set("description", "an extension")
           .Set("permissions", ListBuilder().Append("alarms").Build())
           .Set("manifest_version", 2)
           .Set("version", "0.1")
           .Build();
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
           .SetManifest(std::move(manifest))
           .SetID(crx_file::id_util::GenerateId("foo"))
           .Build();
   const PermissionSet& required_permissions =
       PermissionsParser::GetRequiredPermissions(extension.get());
   LOG(WARNING) << required_permissions.apis().size();
   EXPECT_TRUE(
       extension->permissions_data()->HasAPIPermission(APIPermission::kAlarms));
   APIPermissionSet tab_permissions;
   tab_permissions.insert(APIPermission::kDns);
   extension->permissions_data()->UpdateTabSpecificPermissions(
       1, PermissionSet(tab_permissions, ManifestPermissionSet(),
                        URLPatternSet(), URLPatternSet()));
+  URLPatternSet runtime_blocked_hosts;
+  AddPattern(&runtime_blocked_hosts, "*://*.example.*/*");
+  URLPatternSet runtime_allowed_hosts;
+  AddPattern(&runtime_allowed_hosts, "*://good.example.com/*");
+  extension->permissions_data()->SetPolicyHostRestrictions(
+      runtime_blocked_hosts, runtime_allowed_hosts);
 
   ExtensionMsg_Loaded_Params params_in(extension.get(), true);
   EXPECT_EQ(extension->id(), params_in.id);
 
   {
     // First, test just converting back to an extension.
     std::string error;
     scoped_refptr<const Extension> extension_out =
         params_in.ConvertToExtension(&error);
     EXPECT_TRUE(error.empty());
@@ skipping 21 matching lines @@
     std::string error;
     scoped_refptr<const Extension> extension_out =
         params_out.ConvertToExtension(&error);
     EXPECT_TRUE(error.empty());
     ASSERT_TRUE(extension_out);
     CompareExtension(*extension, *extension_out);
   }
 }
 
 }  // namespace extensions