chrome/common/extensions/permissions/permission_set_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/json/json_file_value_serializer.h"
   7 #include "base/logging.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "chrome/common/chrome_paths.h"
  12 #include "chrome/common/chrome_switches.h"
  13 #include "chrome/common/extensions/extension_test_util.h"
  14 #include "chrome/common/extensions/features/feature_channel.h"
  15 #include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
  16 #include "chrome/grit/generated_resources.h"
  17 #include "extensions/common/error_utils.h"
  18 #include "extensions/common/extension.h"
  19 #include "extensions/common/extension_builder.h"
  20 #include "extensions/common/permissions/permission_message_provider.h"
  21 #include "extensions/common/permissions/permission_message_test_util.h"
  22 #include "extensions/common/permissions/permission_message_util.h"
  23 #include "extensions/common/permissions/permission_set.h"
  24 #include "extensions/common/permissions/permissions_data.h"
  25 #include "extensions/common/permissions/permissions_info.h"
  26 #include "extensions/common/permissions/socket_permission.h"
  27 #include "extensions/common/value_builder.h"
  28 #include "extensions/strings/grit/extensions_strings.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30 #include "ui/base/l10n/l10n_util.h"
  31
  32 using extension_test_util::LoadManifest;
  33
  34 namespace extensions {
  35
  36 namespace {
  37
  38 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
  39   int schemes = URLPattern::SCHEME_ALL;
  40   extent->AddPattern(URLPattern(schemes, pattern));
  41 }
  42
  43 size_t IndexOf(const PermissionMessageStrings& warnings,
  44                const std::string& warning) {
  45   for (size_t i = 0; i < warnings.size(); ++i) {
  46     if (warnings[i].message == base::ASCIIToUTF16(warning))
  47       return i;
  48   }
  49
  50   return warnings.size();
  51 }
  52
  53 PermissionIDSet MakePermissionIDSet(APIPermission::ID id1,
  54                                     APIPermission::ID id2) {
  55   PermissionIDSet set;
  56   set.insert(id1);
  57   set.insert(id2);
  58   return set;
  59 }
  60
  61 PermissionIDSet MakePermissionIDSet(const APIPermissionSet& permissions) {
  62   PermissionIDSet set;
  63   for (const APIPermission* permission : permissions)
  64     set.insert(permission->id());
  65   return set;
  66 }
  67
  68 std::string LegacyPermissionIDsToString(const PermissionMessageIDs& ids) {
  69   std::vector<std::string> strs;
  70   for (const PermissionMessage::ID& id : ids)
  71     strs.push_back(base::IntToString(id));
  72   return base::StringPrintf("[ %s ]", JoinString(strs, ", ").c_str());
  73 }
  74
  75 std::string PermissionIDsToString(const PermissionIDSet& ids) {
  76   std::vector<std::string> strs;
  77   for (const PermissionID& id : ids)
  78     strs.push_back(base::IntToString(id.id()));
  79   return base::StringPrintf("[ %s ]", JoinString(strs, ", ").c_str());
  80 }
  81
  82 std::string CoalescedPermissionIDsToString(
  83     const CoalescedPermissionMessages& msgs) {
  84   std::vector<std::string> strs;
  85   for (const CoalescedPermissionMessage& msg : msgs)
  86     strs.push_back(PermissionIDsToString(msg.permissions()));
  87   return JoinString(strs, " ");
  88 }
  89
  90 // Check that the given |permissions| produce a single warning message,
  91 // identified by |expected_legacy_id| in the old system, and by the set of
  92 // |expected_ids| in the new system.
  93 testing::AssertionResult PermissionSetProducesMessage(
  94     const PermissionSet* permissions,
  95     Manifest::Type extension_type,
  96     PermissionMessage::ID expected_legacy_id,
  97     const PermissionIDSet& expected_ids) {
  98   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
  99   PermissionMessageIDs legacy_ids =
 100       provider->GetLegacyPermissionMessageIDs(permissions, extension_type);
 101   if (legacy_ids.size() != 1 || expected_legacy_id != legacy_ids[0]) {
 102     return testing::AssertionFailure()
 103            << "Expected single legacy permission ID " << expected_legacy_id
 104            << " but got " << LegacyPermissionIDsToString(legacy_ids);
 105   }
 106
 107   CoalescedPermissionMessages msgs = provider->GetCoalescedPermissionMessages(
 108       provider->GetAllPermissionIDs(permissions, extension_type));
 109   if (msgs.size() != 1) {
 110     return testing::AssertionFailure()
 111            << "Expected single permission message with IDs "
 112            << PermissionIDsToString(expected_ids) << " but got " << msgs.size()
 113            << " messages: " << CoalescedPermissionIDsToString(msgs);
 114   }
 115   if (!msgs.front().permissions().Equals(expected_ids)) {
 116     return testing::AssertionFailure()
 117            << "Expected permission IDs " << PermissionIDsToString(expected_ids)
 118            << " but got " << PermissionIDsToString(msgs.front().permissions());
 119   }
 120
 121   return testing::AssertionSuccess();
 122 }
 123
 124 }  // namespace
 125
 126 // Tests GetByID.
 127 TEST(PermissionsTest, GetByID) {
 128   PermissionsInfo* info = PermissionsInfo::GetInstance();
 129   APIPermissionSet apis = info->GetAll();
 130   for (APIPermissionSet::const_iterator i = apis.begin();
 131        i != apis.end(); ++i) {
 132     EXPECT_EQ(i->id(), i->info()->id());
 133   }
 134 }
 135
 136 // Tests that GetByName works with normal permission names and aliases.
 137 TEST(PermissionsTest, GetByName) {
 138   PermissionsInfo* info = PermissionsInfo::GetInstance();
 139   EXPECT_EQ(APIPermission::kTab, info->GetByName("tabs")->id());
 140   EXPECT_EQ(APIPermission::kManagement,
 141             info->GetByName("management")->id());
 142   EXPECT_FALSE(info->GetByName("alsdkfjasldkfj"));
 143 }
 144
 145 TEST(PermissionsTest, GetAll) {
 146   size_t count = 0;
 147   PermissionsInfo* info = PermissionsInfo::GetInstance();
 148   APIPermissionSet apis = info->GetAll();
 149   for (APIPermissionSet::const_iterator api = apis.begin();
 150        api != apis.end(); ++api) {
 151     // Make sure only the valid permission IDs get returned.
 152     EXPECT_NE(APIPermission::kInvalid, api->id());
 153     EXPECT_NE(APIPermission::kUnknown, api->id());
 154     count++;
 155   }
 156   EXPECT_EQ(count, info->get_permission_count());
 157 }
 158
 159 TEST(PermissionsTest, GetAllByName) {
 160   std::set<std::string> names;
 161   names.insert("background");
 162   names.insert("management");
 163
 164   // This is an alias of kTab
 165   names.insert("windows");
 166
 167   // This unknown name should get dropped.
 168   names.insert("sdlkfjasdlkfj");
 169
 170   APIPermissionSet expected;
 171   expected.insert(APIPermission::kBackground);
 172   expected.insert(APIPermission::kManagement);
 173   expected.insert(APIPermission::kTab);
 174
 175   EXPECT_EQ(expected,
 176             PermissionsInfo::GetInstance()->GetAllByName(names));
 177 }
 178
 179 // Tests that the aliases are properly mapped.
 180 TEST(PermissionsTest, Aliases) {
 181   PermissionsInfo* info = PermissionsInfo::GetInstance();
 182   // tabs: tabs, windows
 183   std::string tabs_name = "tabs";
 184   EXPECT_EQ(tabs_name, info->GetByID(APIPermission::kTab)->name());
 185   EXPECT_EQ(APIPermission::kTab, info->GetByName("tabs")->id());
 186   EXPECT_EQ(APIPermission::kTab, info->GetByName("windows")->id());
 187
 188   // unlimitedStorage: unlimitedStorage, unlimited_storage
 189   std::string storage_name = "unlimitedStorage";
 190   EXPECT_EQ(storage_name, info->GetByID(
 191       APIPermission::kUnlimitedStorage)->name());
 192   EXPECT_EQ(APIPermission::kUnlimitedStorage,
 193             info->GetByName("unlimitedStorage")->id());
 194   EXPECT_EQ(APIPermission::kUnlimitedStorage,
 195             info->GetByName("unlimited_storage")->id());
 196 }
 197
 198 TEST(PermissionsTest, EffectiveHostPermissions) {
 199   scoped_refptr<Extension> extension;
 200   scoped_refptr<const PermissionSet> permissions;
 201
 202   extension = LoadManifest("effective_host_permissions", "empty.json");
 203   permissions = extension->permissions_data()->active_permissions();
 204   EXPECT_EQ(0u,
 205             extension->permissions_data()
 206                 ->GetEffectiveHostPermissions()
 207                 .patterns()
 208                 .size());
 209   EXPECT_FALSE(
 210       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
 211   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 212
 213   extension = LoadManifest("effective_host_permissions", "one_host.json");
 214   permissions = extension->permissions_data()->active_permissions();
 215   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
 216       GURL("http://www.google.com")));
 217   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(
 218       GURL("https://www.google.com")));
 219   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 220
 221   extension = LoadManifest("effective_host_permissions",
 222                            "one_host_wildcard.json");
 223   permissions = extension->permissions_data()->active_permissions();
 224   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://google.com")));
 225   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
 226       GURL("http://foo.google.com")));
 227   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 228
 229   extension = LoadManifest("effective_host_permissions", "two_hosts.json");
 230   permissions = extension->permissions_data()->active_permissions();
 231   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
 232       GURL("http://www.google.com")));
 233   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
 234       GURL("http://www.reddit.com")));
 235   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 236
 237   extension = LoadManifest("effective_host_permissions",
 238                            "https_not_considered.json");
 239   permissions = extension->permissions_data()->active_permissions();
 240   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://google.com")));
 241   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("https://google.com")));
 242   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 243
 244   extension = LoadManifest("effective_host_permissions",
 245                            "two_content_scripts.json");
 246   permissions = extension->permissions_data()->active_permissions();
 247   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://google.com")));
 248   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
 249       GURL("http://www.reddit.com")));
 250   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
 251       GURL("http://news.ycombinator.com")));
 252   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 253
 254   extension = LoadManifest("effective_host_permissions", "all_hosts.json");
 255   permissions = extension->permissions_data()->active_permissions();
 256   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
 257   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(GURL("https://test/")));
 258   EXPECT_TRUE(
 259       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
 260   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 261
 262   extension = LoadManifest("effective_host_permissions", "all_hosts2.json");
 263   permissions = extension->permissions_data()->active_permissions();
 264   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
 265   EXPECT_TRUE(
 266       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
 267   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 268
 269   extension = LoadManifest("effective_host_permissions", "all_hosts3.json");
 270   permissions = extension->permissions_data()->active_permissions();
 271   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
 272   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("https://test/")));
 273   EXPECT_TRUE(
 274       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
 275   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 276 }
 277
 278 TEST(PermissionsTest, ExplicitAccessToOrigin) {
 279   APIPermissionSet apis;
 280   ManifestPermissionSet manifest_permissions;
 281   URLPatternSet explicit_hosts;
 282   URLPatternSet scriptable_hosts;
 283
 284   AddPattern(&explicit_hosts, "http://*.google.com/*");
 285   // The explicit host paths should get set to /*.
 286   AddPattern(&explicit_hosts, "http://www.example.com/a/particular/path/*");
 287
 288   scoped_refptr<PermissionSet> perm_set = new PermissionSet(
 289       apis, manifest_permissions, explicit_hosts, scriptable_hosts);
 290   ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
 291       GURL("http://www.google.com/")));
 292   ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
 293       GURL("http://test.google.com/")));
 294   ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
 295       GURL("http://www.example.com")));
 296   ASSERT_TRUE(perm_set->HasEffectiveAccessToURL(
 297       GURL("http://www.example.com")));
 298   ASSERT_FALSE(perm_set->HasExplicitAccessToOrigin(
 299       GURL("http://test.example.com")));
 300 }
 301
 302 TEST(PermissionsTest, CreateUnion) {
 303   APIPermission* permission = NULL;
 304
 305   ManifestPermissionSet manifest_permissions;
 306   APIPermissionSet apis1;
 307   APIPermissionSet apis2;
 308   APIPermissionSet expected_apis;
 309
 310   URLPatternSet explicit_hosts1;
 311   URLPatternSet explicit_hosts2;
 312   URLPatternSet expected_explicit_hosts;
 313
 314   URLPatternSet scriptable_hosts1;
 315   URLPatternSet scriptable_hosts2;
 316   URLPatternSet expected_scriptable_hosts;
 317
 318   URLPatternSet effective_hosts;
 319
 320   scoped_refptr<PermissionSet> set1;
 321   scoped_refptr<PermissionSet> set2;
 322   scoped_refptr<PermissionSet> union_set;
 323
 324   const APIPermissionInfo* permission_info =
 325     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 326   permission = permission_info->CreateAPIPermission();
 327   {
 328     scoped_ptr<base::ListValue> value(new base::ListValue());
 329     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 330     value->Append(new base::StringValue("udp-bind::8080"));
 331     value->Append(new base::StringValue("udp-send-to::8888"));
 332     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 333   }
 334
 335   // Union with an empty set.
 336   apis1.insert(APIPermission::kTab);
 337   apis1.insert(APIPermission::kBackground);
 338   apis1.insert(permission->Clone());
 339   expected_apis.insert(APIPermission::kTab);
 340   expected_apis.insert(APIPermission::kBackground);
 341   expected_apis.insert(permission);
 342
 343   AddPattern(&explicit_hosts1, "http://*.google.com/*");
 344   AddPattern(&expected_explicit_hosts, "http://*.google.com/*");
 345   AddPattern(&effective_hosts, "http://*.google.com/*");
 346
 347   set1 = new PermissionSet(apis1, manifest_permissions,
 348                            explicit_hosts1, scriptable_hosts1);
 349   set2 = new PermissionSet(apis2, manifest_permissions,
 350                            explicit_hosts2, scriptable_hosts2);
 351   union_set = PermissionSet::CreateUnion(set1.get(), set2.get());
 352   EXPECT_TRUE(set1->Contains(*set2.get()));
 353   EXPECT_TRUE(set1->Contains(*union_set.get()));
 354   EXPECT_FALSE(set2->Contains(*set1.get()));
 355   EXPECT_FALSE(set2->Contains(*union_set.get()));
 356   EXPECT_TRUE(union_set->Contains(*set1.get()));
 357   EXPECT_TRUE(union_set->Contains(*set2.get()));
 358
 359   EXPECT_FALSE(union_set->HasEffectiveFullAccess());
 360   EXPECT_EQ(expected_apis, union_set->apis());
 361   EXPECT_EQ(expected_explicit_hosts, union_set->explicit_hosts());
 362   EXPECT_EQ(expected_scriptable_hosts, union_set->scriptable_hosts());
 363   EXPECT_EQ(expected_explicit_hosts, union_set->effective_hosts());
 364
 365   // Now use a real second set.
 366   apis2.insert(APIPermission::kTab);
 367   apis2.insert(APIPermission::kProxy);
 368   apis2.insert(APIPermission::kClipboardWrite);
 369   apis2.insert(APIPermission::kPlugin);
 370
 371   permission = permission_info->CreateAPIPermission();
 372   {
 373     scoped_ptr<base::ListValue> value(new base::ListValue());
 374     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 375     value->Append(new base::StringValue("udp-send-to::8899"));
 376     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 377   }
 378   apis2.insert(permission);
 379
 380   expected_apis.insert(APIPermission::kTab);
 381   expected_apis.insert(APIPermission::kProxy);
 382   expected_apis.insert(APIPermission::kClipboardWrite);
 383   expected_apis.insert(APIPermission::kPlugin);
 384
 385   permission = permission_info->CreateAPIPermission();
 386   {
 387     scoped_ptr<base::ListValue> value(new base::ListValue());
 388     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 389     value->Append(new base::StringValue("udp-bind::8080"));
 390     value->Append(new base::StringValue("udp-send-to::8888"));
 391     value->Append(new base::StringValue("udp-send-to::8899"));
 392     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 393   }
 394   // Insert a new permission socket permisssion which will replace the old one.
 395   expected_apis.insert(permission);
 396
 397   AddPattern(&explicit_hosts2, "http://*.example.com/*");
 398   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
 399   AddPattern(&expected_explicit_hosts, "http://*.example.com/*");
 400   AddPattern(&expected_scriptable_hosts, "http://*.google.com/*");
 401
 402   URLPatternSet::CreateUnion(
 403       explicit_hosts2, scriptable_hosts2, &effective_hosts);
 404
 405   set2 = new PermissionSet(apis2, manifest_permissions,
 406                            explicit_hosts2, scriptable_hosts2);
 407   union_set = PermissionSet::CreateUnion(set1.get(), set2.get());
 408
 409   EXPECT_FALSE(set1->Contains(*set2.get()));
 410   EXPECT_FALSE(set1->Contains(*union_set.get()));
 411   EXPECT_FALSE(set2->Contains(*set1.get()));
 412   EXPECT_FALSE(set2->Contains(*union_set.get()));
 413   EXPECT_TRUE(union_set->Contains(*set1.get()));
 414   EXPECT_TRUE(union_set->Contains(*set2.get()));
 415
 416   EXPECT_TRUE(union_set->HasEffectiveFullAccess());
 417   EXPECT_TRUE(union_set->HasEffectiveAccessToAllHosts());
 418   EXPECT_EQ(expected_apis, union_set->apis());
 419   EXPECT_EQ(expected_explicit_hosts, union_set->explicit_hosts());
 420   EXPECT_EQ(expected_scriptable_hosts, union_set->scriptable_hosts());
 421   EXPECT_EQ(effective_hosts, union_set->effective_hosts());
 422 }
 423
 424 TEST(PermissionsTest, CreateIntersection) {
 425   APIPermission* permission = NULL;
 426
 427   ManifestPermissionSet manifest_permissions;
 428   APIPermissionSet apis1;
 429   APIPermissionSet apis2;
 430   APIPermissionSet expected_apis;
 431
 432   URLPatternSet explicit_hosts1;
 433   URLPatternSet explicit_hosts2;
 434   URLPatternSet expected_explicit_hosts;
 435
 436   URLPatternSet scriptable_hosts1;
 437   URLPatternSet scriptable_hosts2;
 438   URLPatternSet expected_scriptable_hosts;
 439
 440   URLPatternSet effective_hosts;
 441
 442   scoped_refptr<PermissionSet> set1;
 443   scoped_refptr<PermissionSet> set2;
 444   scoped_refptr<PermissionSet> new_set;
 445
 446   const APIPermissionInfo* permission_info =
 447     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 448
 449   // Intersection with an empty set.
 450   apis1.insert(APIPermission::kTab);
 451   apis1.insert(APIPermission::kBackground);
 452   permission = permission_info->CreateAPIPermission();
 453   {
 454     scoped_ptr<base::ListValue> value(new base::ListValue());
 455     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 456     value->Append(new base::StringValue("udp-bind::8080"));
 457     value->Append(new base::StringValue("udp-send-to::8888"));
 458     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 459   }
 460   apis1.insert(permission);
 461
 462   AddPattern(&explicit_hosts1, "http://*.google.com/*");
 463   AddPattern(&scriptable_hosts1, "http://www.reddit.com/*");
 464
 465   set1 = new PermissionSet(apis1, manifest_permissions,
 466                            explicit_hosts1, scriptable_hosts1);
 467   set2 = new PermissionSet(apis2, manifest_permissions,
 468                            explicit_hosts2, scriptable_hosts2);
 469   new_set = PermissionSet::CreateIntersection(set1.get(), set2.get());
 470   EXPECT_TRUE(set1->Contains(*new_set.get()));
 471   EXPECT_TRUE(set2->Contains(*new_set.get()));
 472   EXPECT_TRUE(set1->Contains(*set2.get()));
 473   EXPECT_FALSE(set2->Contains(*set1.get()));
 474   EXPECT_FALSE(new_set->Contains(*set1.get()));
 475   EXPECT_TRUE(new_set->Contains(*set2.get()));
 476
 477   EXPECT_TRUE(new_set->IsEmpty());
 478   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
 479   EXPECT_EQ(expected_apis, new_set->apis());
 480   EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
 481   EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
 482   EXPECT_EQ(expected_explicit_hosts, new_set->effective_hosts());
 483
 484   // Now use a real second set.
 485   apis2.insert(APIPermission::kTab);
 486   apis2.insert(APIPermission::kProxy);
 487   apis2.insert(APIPermission::kClipboardWrite);
 488   apis2.insert(APIPermission::kPlugin);
 489   permission = permission_info->CreateAPIPermission();
 490   {
 491     scoped_ptr<base::ListValue> value(new base::ListValue());
 492     value->Append(new base::StringValue("udp-bind::8080"));
 493     value->Append(new base::StringValue("udp-send-to::8888"));
 494     value->Append(new base::StringValue("udp-send-to::8899"));
 495     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 496   }
 497   apis2.insert(permission);
 498
 499   expected_apis.insert(APIPermission::kTab);
 500   permission = permission_info->CreateAPIPermission();
 501   {
 502     scoped_ptr<base::ListValue> value(new base::ListValue());
 503     value->Append(new base::StringValue("udp-bind::8080"));
 504     value->Append(new base::StringValue("udp-send-to::8888"));
 505     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 506   }
 507   expected_apis.insert(permission);
 508
 509   AddPattern(&explicit_hosts2, "http://*.example.com/*");
 510   AddPattern(&explicit_hosts2, "http://*.google.com/*");
 511   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
 512   AddPattern(&expected_explicit_hosts, "http://*.google.com/*");
 513
 514   effective_hosts.ClearPatterns();
 515   AddPattern(&effective_hosts, "http://*.google.com/*");
 516
 517   set2 = new PermissionSet(apis2, manifest_permissions,
 518                            explicit_hosts2, scriptable_hosts2);
 519   new_set = PermissionSet::CreateIntersection(set1.get(), set2.get());
 520
 521   EXPECT_TRUE(set1->Contains(*new_set.get()));
 522   EXPECT_TRUE(set2->Contains(*new_set.get()));
 523   EXPECT_FALSE(set1->Contains(*set2.get()));
 524   EXPECT_FALSE(set2->Contains(*set1.get()));
 525   EXPECT_FALSE(new_set->Contains(*set1.get()));
 526   EXPECT_FALSE(new_set->Contains(*set2.get()));
 527
 528   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
 529   EXPECT_FALSE(new_set->HasEffectiveAccessToAllHosts());
 530   EXPECT_EQ(expected_apis, new_set->apis());
 531   EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
 532   EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
 533   EXPECT_EQ(effective_hosts, new_set->effective_hosts());
 534 }
 535
 536 TEST(PermissionsTest, CreateDifference) {
 537   APIPermission* permission = NULL;
 538
 539   ManifestPermissionSet manifest_permissions;
 540   APIPermissionSet apis1;
 541   APIPermissionSet apis2;
 542   APIPermissionSet expected_apis;
 543
 544   URLPatternSet explicit_hosts1;
 545   URLPatternSet explicit_hosts2;
 546   URLPatternSet expected_explicit_hosts;
 547
 548   URLPatternSet scriptable_hosts1;
 549   URLPatternSet scriptable_hosts2;
 550   URLPatternSet expected_scriptable_hosts;
 551
 552   URLPatternSet effective_hosts;
 553
 554   scoped_refptr<PermissionSet> set1;
 555   scoped_refptr<PermissionSet> set2;
 556   scoped_refptr<PermissionSet> new_set;
 557
 558   const APIPermissionInfo* permission_info =
 559     PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 560
 561   // Difference with an empty set.
 562   apis1.insert(APIPermission::kTab);
 563   apis1.insert(APIPermission::kBackground);
 564   permission = permission_info->CreateAPIPermission();
 565   {
 566     scoped_ptr<base::ListValue> value(new base::ListValue());
 567     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 568     value->Append(new base::StringValue("udp-bind::8080"));
 569     value->Append(new base::StringValue("udp-send-to::8888"));
 570     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 571   }
 572   apis1.insert(permission);
 573
 574   AddPattern(&explicit_hosts1, "http://*.google.com/*");
 575   AddPattern(&scriptable_hosts1, "http://www.reddit.com/*");
 576
 577   set1 = new PermissionSet(apis1, manifest_permissions,
 578                            explicit_hosts1, scriptable_hosts1);
 579   set2 = new PermissionSet(apis2, manifest_permissions,
 580                            explicit_hosts2, scriptable_hosts2);
 581   new_set = PermissionSet::CreateDifference(set1.get(), set2.get());
 582   EXPECT_EQ(*set1.get(), *new_set.get());
 583
 584   // Now use a real second set.
 585   apis2.insert(APIPermission::kTab);
 586   apis2.insert(APIPermission::kProxy);
 587   apis2.insert(APIPermission::kClipboardWrite);
 588   apis2.insert(APIPermission::kPlugin);
 589   permission = permission_info->CreateAPIPermission();
 590   {
 591     scoped_ptr<base::ListValue> value(new base::ListValue());
 592     value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 593     value->Append(new base::StringValue("udp-send-to::8899"));
 594     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 595   }
 596   apis2.insert(permission);
 597
 598   expected_apis.insert(APIPermission::kBackground);
 599   permission = permission_info->CreateAPIPermission();
 600   {
 601     scoped_ptr<base::ListValue> value(new base::ListValue());
 602     value->Append(new base::StringValue("udp-bind::8080"));
 603     value->Append(new base::StringValue("udp-send-to::8888"));
 604     ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 605   }
 606   expected_apis.insert(permission);
 607
 608   AddPattern(&explicit_hosts2, "http://*.example.com/*");
 609   AddPattern(&explicit_hosts2, "http://*.google.com/*");
 610   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
 611   AddPattern(&expected_scriptable_hosts, "http://www.reddit.com/*");
 612
 613   effective_hosts.ClearPatterns();
 614   AddPattern(&effective_hosts, "http://www.reddit.com/*");
 615
 616   set2 = new PermissionSet(apis2, manifest_permissions,
 617                            explicit_hosts2, scriptable_hosts2);
 618   new_set = PermissionSet::CreateDifference(set1.get(), set2.get());
 619
 620   EXPECT_TRUE(set1->Contains(*new_set.get()));
 621   EXPECT_FALSE(set2->Contains(*new_set.get()));
 622
 623   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
 624   EXPECT_FALSE(new_set->HasEffectiveAccessToAllHosts());
 625   EXPECT_EQ(expected_apis, new_set->apis());
 626   EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
 627   EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
 628   EXPECT_EQ(effective_hosts, new_set->effective_hosts());
 629
 630   // |set3| = |set1| - |set2| --> |set3| intersect |set2| == empty_set
 631   set1 = PermissionSet::CreateIntersection(new_set.get(), set2.get());
 632   EXPECT_TRUE(set1->IsEmpty());
 633 }
 634
 635 TEST(PermissionsTest, IsPrivilegeIncrease) {
 636   const struct {
 637     const char* base_name;
 638     bool expect_increase;
 639   } kTests[] = {
 640     { "allhosts1", false },  // all -> all
 641     { "allhosts2", false },  // all -> one
 642     { "allhosts3", true },  // one -> all
 643     { "hosts1", false },  // http://a,http://b -> http://a,http://b
 644     { "hosts2", true },  // http://a,http://b -> https://a,http://*.b
 645     { "hosts3", false },  // http://a,http://b -> http://a
 646     { "hosts4", true },  // http://a -> http://a,http://b
 647     { "hosts5", false },  // http://a,b,c -> http://a,b,c + https://a,b,c
 648     { "hosts6", false },  // http://a.com -> http://a.com + http://a.co.uk
 649     { "permissions1", false },  // tabs -> tabs
 650     { "permissions2", true },  // tabs -> tabs,bookmarks
 651     { "permissions3", true },  // http://a -> http://a,tabs
 652     { "permissions5", true },  // bookmarks -> bookmarks,history
 653     { "equivalent_warnings", false },  // tabs --> tabs, webNavigation
 654 #if !defined(OS_CHROMEOS)  // plugins aren't allowed in ChromeOS
 655     { "permissions4", false },  // plugin -> plugin,tabs
 656     { "plugin1", false },  // plugin -> plugin
 657     { "plugin2", false },  // plugin -> none
 658     { "plugin3", true },  // none -> plugin
 659 #endif
 660     { "storage", false },  // none -> storage
 661     { "notifications", false },  // none -> notifications
 662     { "platformapp1", false },  // host permissions for platform apps
 663     { "platformapp2", true },  // API permissions for platform apps
 664     { "media_galleries1", true },  // all -> read|all
 665     { "media_galleries2", true },  // read|all -> read|delete|copyTo|all
 666     { "media_galleries3", true },  // all -> read|delete|all
 667     { "media_galleries4", false },  // read|all -> all
 668     { "media_galleries5", false },  // read|copyTo|delete|all -> read|all
 669     { "media_galleries6", false },  // read|all -> read|all
 670     { "media_galleries7", true },  // read|delete|all -> read|copyTo|delete|all
 671     { "sockets1", true },  // none -> tcp:*:*
 672     { "sockets2", false },  // tcp:*:* -> tcp:*:*
 673     { "sockets3", true },  // tcp:a.com:80 -> tcp:*:*
 674   };
 675
 676   for (size_t i = 0; i < arraysize(kTests); ++i) {
 677     scoped_refptr<Extension> old_extension(
 678         LoadManifest("allow_silent_upgrade",
 679                      std::string(kTests[i].base_name) + "_old.json"));
 680     scoped_refptr<Extension> new_extension(
 681         LoadManifest("allow_silent_upgrade",
 682                      std::string(kTests[i].base_name) + "_new.json"));
 683
 684     EXPECT_TRUE(new_extension.get()) << kTests[i].base_name << "_new.json";
 685     if (!new_extension.get())
 686       continue;
 687
 688     scoped_refptr<const PermissionSet> old_p(
 689         old_extension->permissions_data()->active_permissions());
 690     scoped_refptr<const PermissionSet> new_p(
 691         new_extension->permissions_data()->active_permissions());
 692     Manifest::Type extension_type = old_extension->GetType();
 693
 694     bool increased = PermissionMessageProvider::Get()->IsPrivilegeIncrease(
 695         old_p.get(), new_p.get(), extension_type);
 696     EXPECT_EQ(kTests[i].expect_increase, increased) << kTests[i].base_name;
 697   }
 698 }
 699
 700 TEST(PermissionsTest, PermissionMessages) {
 701   // Ensure that all permissions that needs to show install UI actually have
 702   // strings associated with them.
 703   APIPermissionSet skip;
 704
 705   // These are considered "nuisance" or "trivial" permissions that don't need
 706   // a prompt.
 707   skip.insert(APIPermission::kActiveTab);
 708   skip.insert(APIPermission::kAlarms);
 709   skip.insert(APIPermission::kAlphaEnabled);
 710   skip.insert(APIPermission::kAlwaysOnTopWindows);
 711   skip.insert(APIPermission::kAppView);
 712   skip.insert(APIPermission::kAudio);
 713   skip.insert(APIPermission::kAudioModem);
 714   skip.insert(APIPermission::kBrowsingData);
 715   skip.insert(APIPermission::kCastStreaming);
 716   skip.insert(APIPermission::kCommandsAccessibility);
 717   skip.insert(APIPermission::kContextMenus);
 718   skip.insert(APIPermission::kCryptotokenPrivate);
 719   skip.insert(APIPermission::kCopresencePrivate);
 720   skip.insert(APIPermission::kDesktopCapturePrivate);
 721   skip.insert(APIPermission::kDiagnostics);
 722   skip.insert(APIPermission::kDns);
 723   skip.insert(APIPermission::kDownloadsShelf);
 724   skip.insert(APIPermission::kEmbeddedExtensionOptions);
 725   skip.insert(APIPermission::kExtensionView);
 726   skip.insert(APIPermission::kFontSettings);
 727   skip.insert(APIPermission::kFullscreen);
 728   skip.insert(APIPermission::kGcm);
 729   skip.insert(APIPermission::kIdle);
 730   skip.insert(APIPermission::kImeWindowEnabled);
 731   skip.insert(APIPermission::kInlineInstallPrivate);
 732   skip.insert(APIPermission::kIdltest);
 733   skip.insert(APIPermission::kLogPrivate);
 734   skip.insert(APIPermission::kNotifications);
 735   skip.insert(APIPermission::kNotificationProvider);
 736   skip.insert(APIPermission::kOverrideEscFullscreen);
 737   skip.insert(APIPermission::kPointerLock);
 738   skip.insert(APIPermission::kPower);
 739   skip.insert(APIPermission::kPrinterProvider);
 740   skip.insert(APIPermission::kSessions);
 741   skip.insert(APIPermission::kStorage);
 742   skip.insert(APIPermission::kSystemCpu);
 743   skip.insert(APIPermission::kSystemDisplay);
 744   skip.insert(APIPermission::kSystemMemory);
 745   skip.insert(APIPermission::kSystemNetwork);
 746   skip.insert(APIPermission::kSystemStorage);
 747   skip.insert(APIPermission::kTts);
 748   skip.insert(APIPermission::kUnlimitedStorage);
 749   skip.insert(APIPermission::kWebcamPrivate);
 750   skip.insert(APIPermission::kWebView);
 751   skip.insert(APIPermission::kWindowShape);
 752
 753   // These permissions are restricted to extensions force-installed by policy
 754   // and don't require a prompt, i.e. they're restricted to location 'policy'.
 755   skip.insert(APIPermission::kEnterprisePlatformKeys);
 756
 757   // TODO(erikkay) add a string for this permission.
 758   skip.insert(APIPermission::kBackground);
 759
 760   skip.insert(APIPermission::kClipboardWrite);
 761
 762   // The cookie permission does nothing unless you have associated host
 763   // permissions.
 764   skip.insert(APIPermission::kCookie);
 765
 766   // These are warned as part of host permission checks.
 767   skip.insert(APIPermission::kDataReductionProxy);
 768   skip.insert(APIPermission::kDeclarativeContent);
 769   skip.insert(APIPermission::kPageCapture);
 770   skip.insert(APIPermission::kProxy);
 771   skip.insert(APIPermission::kTabCapture);
 772   skip.insert(APIPermission::kWebRequest);
 773   skip.insert(APIPermission::kWebRequestBlocking);
 774
 775   // This permission requires explicit user action (context menu handler)
 776   // so we won't prompt for it for now.
 777   skip.insert(APIPermission::kFileBrowserHandler);
 778
 779   // These permissions require explicit user action (configuration dialog)
 780   // so we don't prompt for them at install time.
 781   skip.insert(APIPermission::kMediaGalleries);
 782
 783   // If you've turned on the experimental command-line flag, we don't need
 784   // to warn you further.
 785   skip.insert(APIPermission::kExperimental);
 786
 787   // The Identity API has its own server-driven permission prompts.
 788   skip.insert(APIPermission::kIdentity);
 789
 790   // These are private.
 791   skip.insert(APIPermission::kAccessibilityPrivate);
 792   skip.insert(APIPermission::kAutoTestPrivate);
 793   skip.insert(APIPermission::kBookmarkManagerPrivate);
 794   skip.insert(APIPermission::kBrailleDisplayPrivate);
 795   skip.insert(APIPermission::kCast);
 796   skip.insert(APIPermission::kCastStreaming);
 797   skip.insert(APIPermission::kChromeosInfoPrivate);
 798   skip.insert(APIPermission::kCloudPrintPrivate);
 799   skip.insert(APIPermission::kCommandLinePrivate);
 800   skip.insert(APIPermission::kDeveloperPrivate);
 801   skip.insert(APIPermission::kDial);
 802   skip.insert(APIPermission::kDownloadsInternal);
 803   skip.insert(APIPermission::kEasyUnlockPrivate);
 804   skip.insert(APIPermission::kEchoPrivate);
 805   skip.insert(APIPermission::kEnterprisePlatformKeysPrivate);
 806   skip.insert(APIPermission::kFeedbackPrivate);
 807   skip.insert(APIPermission::kFileBrowserHandlerInternal);
 808   skip.insert(APIPermission::kFileManagerPrivate);
 809   skip.insert(APIPermission::kFirstRunPrivate);
 810   skip.insert(APIPermission::kGcdPrivate);
 811   skip.insert(APIPermission::kHotwordPrivate);
 812   skip.insert(APIPermission::kIdentityPrivate);
 813   skip.insert(APIPermission::kInputMethodPrivate);
 814   skip.insert(APIPermission::kMediaPlayerPrivate);
 815   skip.insert(APIPermission::kMediaRouterPrivate);
 816   skip.insert(APIPermission::kMetricsPrivate);
 817   skip.insert(APIPermission::kPreferencesPrivate);
 818   skip.insert(APIPermission::kPrincipalsPrivate);
 819   skip.insert(APIPermission::kImageWriterPrivate);
 820   skip.insert(APIPermission::kReadingListPrivate);
 821   skip.insert(APIPermission::kRtcPrivate);
 822   skip.insert(APIPermission::kStreamsPrivate);
 823   skip.insert(APIPermission::kSystemPrivate);
 824   skip.insert(APIPermission::kTabCaptureForTab);
 825   skip.insert(APIPermission::kTerminalPrivate);
 826   skip.insert(APIPermission::kVirtualKeyboardPrivate);
 827   skip.insert(APIPermission::kWallpaperPrivate);
 828   skip.insert(APIPermission::kWebrtcAudioPrivate);
 829   skip.insert(APIPermission::kWebrtcDesktopCapturePrivate);
 830   skip.insert(APIPermission::kWebrtcLoggingPrivate);
 831   skip.insert(APIPermission::kWebstorePrivate);
 832   skip.insert(APIPermission::kWebstoreWidgetPrivate);
 833
 834   // Warned as part of host permissions.
 835   skip.insert(APIPermission::kDevtools);
 836
 837   // Platform apps.
 838   skip.insert(APIPermission::kBrowser);
 839   skip.insert(APIPermission::kHid);
 840   skip.insert(APIPermission::kFileSystem);
 841   skip.insert(APIPermission::kFileSystemProvider);
 842   skip.insert(APIPermission::kFileSystemRequestFileSystem);
 843   skip.insert(APIPermission::kFileSystemRetainEntries);
 844   skip.insert(APIPermission::kFileSystemWrite);
 845   skip.insert(APIPermission::kSocket);
 846   skip.insert(APIPermission::kUsb);
 847   skip.insert(APIPermission::kUsbDevice);
 848   skip.insert(APIPermission::kLauncherSearchProvider);
 849
 850   // We already have a generic message for declaring externally_connectable.
 851   skip.insert(APIPermission::kExternallyConnectableAllUrls);
 852
 853   PermissionsInfo* info = PermissionsInfo::GetInstance();
 854   APIPermissionSet permissions = info->GetAll();
 855   for (APIPermissionSet::const_iterator i = permissions.begin();
 856        i != permissions.end(); ++i) {
 857     const APIPermissionInfo* permission_info = i->info();
 858     EXPECT_TRUE(permission_info != NULL);
 859
 860     if (skip.count(i->id())) {
 861       EXPECT_EQ(PermissionMessage::kNone, permission_info->message_id())
 862           << "unexpected message_id for " << permission_info->name();
 863     } else {
 864       EXPECT_NE(PermissionMessage::kNone, permission_info->message_id())
 865           << "missing message_id for " << permission_info->name();
 866     }
 867   }
 868 }
 869
 870 TEST(PermissionsTest, FileSystemPermissionMessages) {
 871   APIPermissionSet api_permissions;
 872   api_permissions.insert(APIPermission::kFileSystemWrite);
 873   api_permissions.insert(APIPermission::kFileSystemDirectory);
 874   scoped_refptr<PermissionSet> permissions(
 875       new PermissionSet(api_permissions, ManifestPermissionSet(),
 876                         URLPatternSet(), URLPatternSet()));
 877   EXPECT_TRUE(PermissionSetProducesMessage(
 878       permissions.get(), Manifest::TYPE_PLATFORM_APP,
 879       PermissionMessage::kFileSystemDirectory,
 880       MakePermissionIDSet(api_permissions)));
 881 }
 882
 883 // The file system permissions have a special-case hack to show a warning for
 884 // write and directory at the same time.
 885 // TODO(sammc): Remove this. See http://crbug.com/284849.
 886 TEST(PermissionsTest, FileSystemImplicitPermissions) {
 887   APIPermissionSet apis;
 888   apis.insert(APIPermission::kFileSystemWrite);
 889   apis.AddImpliedPermissions();
 890
 891   EXPECT_EQ(apis.find(APIPermission::kFileSystemWrite)->id(),
 892             APIPermission::kFileSystemWrite);
 893   EXPECT_EQ(apis.size(), 1u);
 894
 895   apis.erase(APIPermission::kFileSystemWrite);
 896   apis.insert(APIPermission::kFileSystemDirectory);
 897   apis.AddImpliedPermissions();
 898
 899   EXPECT_EQ(apis.find(APIPermission::kFileSystemDirectory)->id(),
 900             APIPermission::kFileSystemDirectory);
 901   EXPECT_EQ(apis.size(), 1u);
 902
 903   apis.insert(APIPermission::kFileSystemWrite);
 904   apis.AddImpliedPermissions();
 905
 906   EXPECT_EQ(apis.find(APIPermission::kFileSystemWrite)->id(),
 907             APIPermission::kFileSystemWrite);
 908   EXPECT_EQ(apis.find(APIPermission::kFileSystemDirectory)->id(),
 909             APIPermission::kFileSystemDirectory);
 910   EXPECT_EQ(apis.find(APIPermission::kFileSystemWriteDirectory)->id(),
 911             APIPermission::kFileSystemWriteDirectory);
 912   EXPECT_EQ(apis.size(), 3u);
 913 }
 914
 915 TEST(PermissionsTest, HiddenFileSystemPermissionMessages) {
 916   APIPermissionSet api_permissions;
 917   api_permissions.insert(APIPermission::kFileSystemWrite);
 918   api_permissions.insert(APIPermission::kFileSystemDirectory);
 919   api_permissions.insert(APIPermission::kFileSystemWriteDirectory);
 920   scoped_refptr<PermissionSet> permissions(
 921       new PermissionSet(api_permissions, ManifestPermissionSet(),
 922                         URLPatternSet(), URLPatternSet()));
 923   EXPECT_TRUE(PermissionSetProducesMessage(
 924       permissions.get(), Manifest::TYPE_PLATFORM_APP,
 925       PermissionMessage::kFileSystemWriteDirectory,
 926       MakePermissionIDSet(api_permissions)));
 927 }
 928
 929 TEST(PermissionsTest, SuppressedPermissionMessages) {
 930   {
 931     // Tabs warning suppresses favicon warning.
 932     APIPermissionSet api_permissions;
 933     api_permissions.insert(APIPermission::kTab);
 934     URLPatternSet hosts;
 935     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI,
 936                                 "chrome://favicon/"));
 937     scoped_refptr<PermissionSet> permissions(
 938         new PermissionSet(api_permissions, ManifestPermissionSet(),
 939                           hosts, URLPatternSet()));
 940     EXPECT_TRUE(PermissionSetProducesMessage(
 941         permissions.get(), Manifest::TYPE_EXTENSION, PermissionMessage::kTabs,
 942         MakePermissionIDSet(APIPermission::kTab, APIPermission::kFavicon)));
 943   }
 944   {
 945     // History warning suppresses favicon warning.
 946     APIPermissionSet api_permissions;
 947     api_permissions.insert(APIPermission::kHistory);
 948     URLPatternSet hosts;
 949     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI,
 950                                 "chrome://favicon/"));
 951     scoped_refptr<PermissionSet> permissions(
 952         new PermissionSet(api_permissions, ManifestPermissionSet(),
 953                           hosts, URLPatternSet()));
 954     EXPECT_TRUE(PermissionSetProducesMessage(
 955         permissions.get(), Manifest::TYPE_EXTENSION,
 956         PermissionMessage::kBrowsingHistory,
 957         MakePermissionIDSet(APIPermission::kHistory, APIPermission::kFavicon)));
 958   }
 959   {
 960     // All sites warning suppresses tabs warning.
 961     APIPermissionSet api_permissions;
 962     api_permissions.insert(APIPermission::kTab);
 963     URLPatternSet hosts;
 964     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
 965     scoped_refptr<PermissionSet> permissions(new PermissionSet(
 966         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
 967     EXPECT_TRUE(PermissionSetProducesMessage(
 968         permissions.get(), Manifest::TYPE_EXTENSION,
 969         PermissionMessage::kHostsAll,
 970         MakePermissionIDSet(APIPermission::kHostsAll, APIPermission::kTab)));
 971   }
 972   {
 973     // All sites warning suppresses topSites warning.
 974     APIPermissionSet api_permissions;
 975     api_permissions.insert(APIPermission::kTopSites);
 976     URLPatternSet hosts;
 977     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
 978     scoped_refptr<PermissionSet> permissions(new PermissionSet(
 979         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
 980     EXPECT_TRUE(PermissionSetProducesMessage(
 981         permissions.get(), Manifest::TYPE_EXTENSION,
 982         PermissionMessage::kHostsAll,
 983         MakePermissionIDSet(APIPermission::kHostsAll,
 984                             APIPermission::kTopSites)));
 985   }
 986   {
 987     // All sites warning suppresses declarativeWebRequest warning.
 988     APIPermissionSet api_permissions;
 989     api_permissions.insert(APIPermission::kDeclarativeWebRequest);
 990     URLPatternSet hosts;
 991     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
 992     scoped_refptr<PermissionSet> permissions(new PermissionSet(
 993         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
 994     EXPECT_TRUE(PermissionSetProducesMessage(
 995         permissions.get(), Manifest::TYPE_EXTENSION,
 996         PermissionMessage::kHostsAll,
 997         MakePermissionIDSet(APIPermission::kHostsAll,
 998                             APIPermission::kDeclarativeWebRequest)));
 999   }
1000   {
1001     // BrowsingHistory warning suppresses all history read/write warnings.
1002     APIPermissionSet api_permissions;
1003     api_permissions.insert(APIPermission::kHistory);
1004     api_permissions.insert(APIPermission::kTab);
1005     api_permissions.insert(APIPermission::kTopSites);
1006     api_permissions.insert(APIPermission::kProcesses);
1007     api_permissions.insert(APIPermission::kWebNavigation);
1008     scoped_refptr<PermissionSet> permissions(
1009         new PermissionSet(api_permissions, ManifestPermissionSet(),
1010                           URLPatternSet(), URLPatternSet()));
1011     EXPECT_TRUE(PermissionSetProducesMessage(
1012         permissions.get(), Manifest::TYPE_EXTENSION,
1013         PermissionMessage::kBrowsingHistory,
1014         MakePermissionIDSet(api_permissions)));
1015   }
1016   {
1017     // Tabs warning suppresses all read-only history warnings.
1018     APIPermissionSet api_permissions;
1019     api_permissions.insert(APIPermission::kTab);
1020     api_permissions.insert(APIPermission::kTopSites);
1021     api_permissions.insert(APIPermission::kProcesses);
1022     api_permissions.insert(APIPermission::kWebNavigation);
1023     scoped_refptr<PermissionSet> permissions(
1024         new PermissionSet(api_permissions, ManifestPermissionSet(),
1025                           URLPatternSet(), URLPatternSet()));
1026     EXPECT_TRUE(PermissionSetProducesMessage(
1027         permissions.get(), Manifest::TYPE_EXTENSION, PermissionMessage::kTabs,
1028         MakePermissionIDSet(api_permissions)));
1029   }
1030 }
1031
1032 TEST(PermissionsTest, AccessToDevicesMessages) {
1033   {
1034     APIPermissionSet api_permissions;
1035     api_permissions.insert(APIPermission::kSerial);
1036     scoped_refptr<PermissionSet> permissions(
1037         new PermissionSet(api_permissions,
1038                           ManifestPermissionSet(),
1039                           URLPatternSet(),
1040                           URLPatternSet()));
1041     VerifyOnePermissionMessage(
1042         permissions.get(), Manifest::TYPE_EXTENSION,
1043         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL));
1044   }
1045   {
1046     // Testing that multiple permissions will show the one message.
1047     APIPermissionSet api_permissions;
1048     api_permissions.insert(APIPermission::kSerial);
1049     api_permissions.insert(APIPermission::kSerial);
1050     scoped_refptr<PermissionSet> permissions(
1051         new PermissionSet(api_permissions,
1052                           ManifestPermissionSet(),
1053                           URLPatternSet(),
1054                           URLPatternSet()));
1055     VerifyOnePermissionMessage(
1056         permissions.get(), Manifest::TYPE_EXTENSION,
1057         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL));
1058   }
1059   {
1060     scoped_refptr<Extension> extension =
1061         LoadManifest("permissions", "access_to_devices_bluetooth.json");
1062     PermissionSet* set = const_cast<PermissionSet*>(
1063         extension->permissions_data()->active_permissions().get());
1064     VerifyOnePermissionMessage(
1065         set, extension->GetType(),
1066         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH));
1067
1068     // Test Bluetooth and Serial
1069     set->apis_.insert(APIPermission::kSerial);
1070     VerifyOnePermissionMessage(
1071         set, extension->GetType(),
1072         l10n_util::GetStringUTF16(
1073             IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_SERIAL));
1074   }
1075 }
1076
1077 TEST(PermissionsTest, MergedFileSystemPermissionComparison) {
1078   APIPermissionSet write_api_permissions;
1079   write_api_permissions.insert(APIPermission::kFileSystemWrite);
1080   scoped_refptr<PermissionSet> write_permissions(
1081       new PermissionSet(write_api_permissions, ManifestPermissionSet(),
1082                         URLPatternSet(), URLPatternSet()));
1083
1084   APIPermissionSet directory_api_permissions;
1085   directory_api_permissions.insert(APIPermission::kFileSystemDirectory);
1086   scoped_refptr<PermissionSet> directory_permissions(
1087       new PermissionSet(directory_api_permissions, ManifestPermissionSet(),
1088                         URLPatternSet(), URLPatternSet()));
1089
1090   APIPermissionSet write_directory_api_permissions;
1091   write_directory_api_permissions.insert(
1092       APIPermission::kFileSystemWriteDirectory);
1093   scoped_refptr<PermissionSet> write_directory_permissions(
1094       new PermissionSet(write_directory_api_permissions,
1095                         ManifestPermissionSet(),
1096                         URLPatternSet(),
1097                         URLPatternSet()));
1098
1099   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
1100   EXPECT_FALSE(provider->IsPrivilegeIncrease(write_directory_permissions.get(),
1101                                              write_permissions.get(),
1102                                              Manifest::TYPE_PLATFORM_APP));
1103   EXPECT_FALSE(provider->IsPrivilegeIncrease(write_directory_permissions.get(),
1104                                              directory_permissions.get(),
1105                                              Manifest::TYPE_PLATFORM_APP));
1106   EXPECT_TRUE(provider->IsPrivilegeIncrease(write_permissions.get(),
1107                                             directory_permissions.get(),
1108                                             Manifest::TYPE_PLATFORM_APP));
1109   EXPECT_TRUE(provider->IsPrivilegeIncrease(write_permissions.get(),
1110                                             write_directory_permissions.get(),
1111                                             Manifest::TYPE_PLATFORM_APP));
1112   EXPECT_FALSE(provider->IsPrivilegeIncrease(directory_permissions.get(),
1113                                              write_permissions.get(),
1114                                              Manifest::TYPE_PLATFORM_APP));
1115   EXPECT_TRUE(provider->IsPrivilegeIncrease(directory_permissions.get(),
1116                                             write_directory_permissions.get(),
1117                                             Manifest::TYPE_PLATFORM_APP));
1118 }
1119
1120 TEST(PermissionsTest, GetWarningMessages_ManyHosts) {
1121   scoped_refptr<Extension> extension;
1122   extension = LoadManifest("permissions", "many-hosts.json");
1123   EXPECT_TRUE(VerifyOnePermissionMessage(
1124       extension->permissions_data(),
1125       "Read and change your data on encrypted.google.com and www.google.com"));
1126 }
1127
1128 TEST(PermissionsTest, GetWarningMessages_Plugins) {
1129   scoped_refptr<Extension> extension;
1130   extension = LoadManifest("permissions", "plugins.json");
1131 // We don't parse the plugins key on Chrome OS, so it should not ask for any
1132 // permissions.
1133 #if defined(OS_CHROMEOS)
1134   EXPECT_TRUE(VerifyNoPermissionMessages(extension->permissions_data()));
1135 #else
1136   EXPECT_TRUE(VerifyOnePermissionMessage(
1137       extension->permissions_data(),
1138       "Read and change all your data on your computer and the websites you "
1139       "visit"));
1140 #endif
1141 }
1142
1143 TEST(PermissionsTest, GetWarningMessages_AudioVideo) {
1144   const std::string kAudio("Use your microphone");
1145   const std::string kVideo("Use your camera");
1146   const std::string kBoth("Use your microphone and camera");
1147
1148   // Both audio and video present.
1149   scoped_refptr<Extension> extension =
1150       LoadManifest("permissions", "audio-video.json");
1151   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
1152   PermissionSet* set = const_cast<PermissionSet*>(
1153       extension->permissions_data()->active_permissions().get());
1154   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kAudio));
1155   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kVideo));
1156   EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(), kBoth));
1157   PermissionMessageStrings warnings =
1158       provider->GetPermissionMessageStrings(set, extension->GetType());
1159   size_t combined_index = IndexOf(warnings, kBoth);
1160   size_t combined_size = warnings.size();
1161
1162   // Just audio present.
1163   set->apis_.erase(APIPermission::kVideoCapture);
1164   EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(), kAudio));
1165   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kVideo));
1166   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kBoth));
1167   warnings = provider->GetPermissionMessageStrings(set, extension->GetType());
1168   EXPECT_EQ(combined_size, warnings.size());
1169   EXPECT_EQ(combined_index, IndexOf(warnings, kAudio));
1170
1171   // Just video present.
1172   set->apis_.erase(APIPermission::kAudioCapture);
1173   set->apis_.insert(APIPermission::kVideoCapture);
1174   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kAudio));
1175   EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(), kVideo));
1176   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(), kBoth));
1177   warnings = provider->GetPermissionMessageStrings(set, extension->GetType());
1178   EXPECT_EQ(combined_size, warnings.size());
1179   EXPECT_EQ(combined_index, IndexOf(warnings, kVideo));
1180 }
1181
1182 TEST(PermissionsTest, GetWarningMessages_CombinedSessions) {
1183   {
1184     APIPermissionSet api_permissions;
1185     api_permissions.insert(APIPermission::kTab);
1186     api_permissions.insert(APIPermission::kTopSites);
1187     api_permissions.insert(APIPermission::kProcesses);
1188     api_permissions.insert(APIPermission::kWebNavigation);
1189     api_permissions.insert(APIPermission::kSessions);
1190     scoped_refptr<PermissionSet> permissions(
1191         new PermissionSet(api_permissions, ManifestPermissionSet(),
1192                           URLPatternSet(), URLPatternSet()));
1193     EXPECT_TRUE(VerifyOnePermissionMessage(
1194         permissions.get(), Manifest::TYPE_EXTENSION,
1195         l10n_util::GetStringUTF16(
1196             IDS_EXTENSION_PROMPT_WARNING_HISTORY_READ_AND_SESSIONS)));
1197   }
1198   {
1199     APIPermissionSet api_permissions;
1200     api_permissions.insert(APIPermission::kHistory);
1201     api_permissions.insert(APIPermission::kTab);
1202     api_permissions.insert(APIPermission::kTopSites);
1203     api_permissions.insert(APIPermission::kProcesses);
1204     api_permissions.insert(APIPermission::kWebNavigation);
1205     api_permissions.insert(APIPermission::kSessions);
1206     scoped_refptr<PermissionSet> permissions(
1207         new PermissionSet(api_permissions, ManifestPermissionSet(),
1208                           URLPatternSet(), URLPatternSet()));
1209     EXPECT_TRUE(VerifyOnePermissionMessage(
1210         permissions.get(), Manifest::TYPE_EXTENSION,
1211         l10n_util::GetStringUTF16(
1212             IDS_EXTENSION_PROMPT_WARNING_HISTORY_WRITE_AND_SESSIONS)));
1213   }
1214 }
1215
1216 TEST(PermissionsTest, GetWarningMessages_DeclarativeWebRequest) {
1217   // Test that if the declarativeWebRequest permission is present
1218   // in combination with all hosts permission, then only the warning
1219   // for host permissions is shown, because that covers the use of
1220   // declarativeWebRequest.
1221
1222   // Until Declarative Web Request is in stable, let's make sure it is enabled
1223   // on the current channel.
1224   ScopedCurrentChannel sc(chrome::VersionInfo::CHANNEL_CANARY);
1225
1226   // First verify that declarativeWebRequest produces a message when host
1227   // permissions do not cover all hosts.
1228   scoped_refptr<Extension> extension =
1229       LoadManifest("permissions", "web_request_not_all_host_permissions.json");
1230   const PermissionSet* set =
1231       extension->permissions_data()->active_permissions().get();
1232   EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(),
1233                                          "Block parts of web pages"));
1234   EXPECT_FALSE(VerifyHasPermissionMessage(
1235       set, extension->GetType(),
1236       "Read and change all your data on the websites you visit"));
1237
1238   // Now verify that declarativeWebRequest does not produce a message when host
1239   // permissions do cover all hosts.
1240   extension =
1241       LoadManifest("permissions", "web_request_all_host_permissions.json");
1242   set = extension->permissions_data()->active_permissions().get();
1243   EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
1244                                           "Block parts of web pages"));
1245   EXPECT_TRUE(VerifyHasPermissionMessage(
1246       set, extension->GetType(),
1247       "Read and change all your data on the websites you visit"));
1248 }
1249
1250 TEST(PermissionsTest, GetWarningMessages_Serial) {
1251   scoped_refptr<Extension> extension =
1252       LoadManifest("permissions", "serial.json");
1253
1254   EXPECT_TRUE(extension->is_platform_app());
1255   EXPECT_TRUE(
1256       extension->permissions_data()->HasAPIPermission(APIPermission::kSerial));
1257   EXPECT_TRUE(VerifyOnePermissionMessage(extension->permissions_data(),
1258                                          "Access your serial devices"));
1259 }
1260
1261 TEST(PermissionsTest, GetWarningMessages_Socket_AnyHost) {
1262   ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
1263
1264   scoped_refptr<Extension> extension =
1265       LoadManifest("permissions", "socket_any_host.json");
1266   EXPECT_TRUE(extension->is_platform_app());
1267   EXPECT_TRUE(
1268       extension->permissions_data()->HasAPIPermission(APIPermission::kSocket));
1269   EXPECT_TRUE(VerifyOnePermissionMessage(
1270       extension->permissions_data(),
1271       "Exchange data with any device on the local network or internet"));
1272 }
1273
1274 TEST(PermissionsTest, GetWarningMessages_Socket_OneDomainTwoHostnames) {
1275   ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
1276
1277   scoped_refptr<Extension> extension =
1278       LoadManifest("permissions", "socket_one_domain_two_hostnames.json");
1279   EXPECT_TRUE(extension->is_platform_app());
1280   EXPECT_TRUE(
1281       extension->permissions_data()->HasAPIPermission(APIPermission::kSocket));
1282
1283   // Verify the warnings, including support for unicode characters, the fact
1284   // that domain host warnings come before specific host warnings, and the fact
1285   // that domains and hostnames are in alphabetical order regardless of the
1286   // order in the manifest file.
1287   EXPECT_TRUE(VerifyTwoPermissionMessages(
1288       extension->permissions_data(),
1289       "Exchange data with any device in the domain example.org",
1290       "Exchange data with the devices named: "
1291       "b\xC3\xA5r.example.com foo.example.com",
1292       // "\xC3\xA5" = UTF-8 for lowercase A with ring above
1293       true));
1294 }
1295
1296 TEST(PermissionsTest, GetWarningMessages_Socket_TwoDomainsOneHostname) {
1297   ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
1298
1299   scoped_refptr<Extension> extension =
1300       LoadManifest("permissions", "socket_two_domains_one_hostname.json");
1301   EXPECT_TRUE(extension->is_platform_app());
1302   EXPECT_TRUE(
1303       extension->permissions_data()->HasAPIPermission(APIPermission::kSocket));
1304
1305   // Verify the warnings, including the fact that domain host warnings come
1306   // before specific host warnings and the fact that domains and hostnames are
1307   // in alphabetical order regardless of the order in the manifest file.
1308   EXPECT_TRUE(VerifyTwoPermissionMessages(
1309       extension->permissions_data(),
1310       "Exchange data with any device in the domains: "
1311       "example.com foo.example.org",
1312       "Exchange data with the device named bar.example.org", true));
1313 }
1314
1315 // Since platform apps always use isolated storage, they can't (silently)
1316 // access user data on other domains, so there's no need to prompt about host
1317 // permissions. See crbug.com/255229.
1318 TEST(PermissionsTest, GetWarningMessages_PlatformAppHosts) {
1319   scoped_refptr<Extension> extension;
1320
1321   extension = LoadManifest("permissions", "platform_app_hosts.json");
1322   EXPECT_TRUE(extension->is_platform_app());
1323   EXPECT_TRUE(VerifyNoPermissionMessages(extension->permissions_data()));
1324
1325   extension = LoadManifest("permissions", "platform_app_all_urls.json");
1326   EXPECT_TRUE(extension->is_platform_app());
1327   EXPECT_TRUE(VerifyNoPermissionMessages(extension->permissions_data()));
1328 }
1329
1330 testing::AssertionResult ShowsAllHostsWarning(const std::string& pattern) {
1331   scoped_refptr<Extension> extension =
1332       ExtensionBuilder()
1333           .SetManifest(DictionaryBuilder()
1334                            .Set("name", "TLDWildCardTest")
1335                            .Set("version", "0.1.0")
1336                            .Set("permissions", ListBuilder().Append(pattern))
1337                            .Build())
1338           .Build();
1339
1340   return VerifyHasPermissionMessage(
1341       extension->permissions_data(),
1342       l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS));
1343 }
1344
1345 TEST(PermissionsTest, GetWarningMessages_TLDWildcardTreatedAsAllHosts) {
1346   EXPECT_TRUE(ShowsAllHostsWarning("http://*.com/*"));    // most popular.
1347   EXPECT_TRUE(ShowsAllHostsWarning("http://*.org/*"));    // sanity check.
1348   EXPECT_TRUE(ShowsAllHostsWarning("http://*.co.uk/*"));  // eTLD.
1349   EXPECT_TRUE(ShowsAllHostsWarning("http://*.de/*"));  // foreign country tld.
1350
1351   // We should still show the normal permissions (i.e., "Can access your data on
1352   // *.rdcronin.com") for things that are not TLDs.
1353   EXPECT_FALSE(ShowsAllHostsWarning("http://*.rdcronin.com/*"));
1354
1355   // Pseudo-TLDs, like appspot.com, should not show all hosts.
1356   EXPECT_FALSE(ShowsAllHostsWarning("http://*.appspot.com/*"));
1357
1358   // Non-TLDs should be likewise exempt.
1359   EXPECT_FALSE(ShowsAllHostsWarning("http://*.notarealtld/*"));
1360
1361   // Our internal checks use "foo", so let's make sure we're not messing
1362   // something up with it.
1363   EXPECT_FALSE(ShowsAllHostsWarning("http://*.foo.com"));
1364   EXPECT_FALSE(ShowsAllHostsWarning("http://foo.com"));
1365   // This will fail if foo becomes a recognized TLD. Which could be soon.
1366   // Update as needed.
1367   EXPECT_FALSE(ShowsAllHostsWarning("http://*.foo"));
1368 }
1369
1370 TEST(PermissionsTest, GetDistinctHosts) {
1371   URLPatternSet explicit_hosts;
1372   std::set<std::string> expected;
1373   expected.insert("www.foo.com");
1374   expected.insert("www.bar.com");
1375   expected.insert("www.baz.com");
1376
1377   {
1378     SCOPED_TRACE("no dupes");
1379
1380     // Simple list with no dupes.
1381     explicit_hosts.AddPattern(
1382         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
1383     explicit_hosts.AddPattern(
1384         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/path"));
1385     explicit_hosts.AddPattern(
1386         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
1387     EXPECT_EQ(expected,
1388               permission_message_util::GetDistinctHosts(
1389                   explicit_hosts, true, true));
1390   }
1391
1392   {
1393     SCOPED_TRACE("two dupes");
1394
1395     // Add some dupes.
1396     explicit_hosts.AddPattern(
1397         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
1398     explicit_hosts.AddPattern(
1399         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
1400     EXPECT_EQ(expected,
1401               permission_message_util::GetDistinctHosts(
1402                   explicit_hosts, true, true));
1403   }
1404
1405   {
1406     SCOPED_TRACE("schemes differ");
1407
1408     // Add a pattern that differs only by scheme. This should be filtered out.
1409     explicit_hosts.AddPattern(
1410         URLPattern(URLPattern::SCHEME_HTTPS, "https://www.bar.com/path"));
1411     EXPECT_EQ(expected,
1412               permission_message_util::GetDistinctHosts(
1413                   explicit_hosts, true, true));
1414   }
1415
1416   {
1417     SCOPED_TRACE("paths differ");
1418
1419     // Add some dupes by path.
1420     explicit_hosts.AddPattern(
1421         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/pathypath"));
1422     EXPECT_EQ(expected,
1423               permission_message_util::GetDistinctHosts(
1424                   explicit_hosts, true, true));
1425   }
1426
1427   {
1428     SCOPED_TRACE("subdomains differ");
1429
1430     // We don't do anything special for subdomains.
1431     explicit_hosts.AddPattern(
1432         URLPattern(URLPattern::SCHEME_HTTP, "http://monkey.www.bar.com/path"));
1433     explicit_hosts.AddPattern(
1434         URLPattern(URLPattern::SCHEME_HTTP, "http://bar.com/path"));
1435
1436     expected.insert("monkey.www.bar.com");
1437     expected.insert("bar.com");
1438
1439     EXPECT_EQ(expected,
1440               permission_message_util::GetDistinctHosts(
1441                   explicit_hosts, true, true));
1442   }
1443
1444   {
1445     SCOPED_TRACE("RCDs differ");
1446
1447     // Now test for RCD uniquing.
1448     explicit_hosts.AddPattern(
1449         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
1450     explicit_hosts.AddPattern(
1451         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
1452     explicit_hosts.AddPattern(
1453         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.de/path"));
1454     explicit_hosts.AddPattern(
1455         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca.us/path"));
1456     explicit_hosts.AddPattern(
1457         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
1458     explicit_hosts.AddPattern(
1459         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com.my/path"));
1460
1461     // This is an unknown RCD, which shouldn't be uniqued out.
1462     explicit_hosts.AddPattern(
1463         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.xyzzy/path"));
1464     // But it should only occur once.
1465     explicit_hosts.AddPattern(
1466         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.xyzzy/path"));
1467
1468     expected.insert("www.foo.xyzzy");
1469
1470     EXPECT_EQ(expected,
1471               permission_message_util::GetDistinctHosts(
1472                   explicit_hosts, true, true));
1473   }
1474
1475   {
1476     SCOPED_TRACE("wildcards");
1477
1478     explicit_hosts.AddPattern(
1479         URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com/*"));
1480
1481     expected.insert("*.google.com");
1482
1483     EXPECT_EQ(expected,
1484               permission_message_util::GetDistinctHosts(
1485                   explicit_hosts, true, true));
1486   }
1487
1488   {
1489     SCOPED_TRACE("scriptable hosts");
1490
1491     APIPermissionSet empty_perms;
1492     explicit_hosts.ClearPatterns();
1493     URLPatternSet scriptable_hosts;
1494     expected.clear();
1495
1496     explicit_hosts.AddPattern(
1497         URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com/*"));
1498     scriptable_hosts.AddPattern(
1499         URLPattern(URLPattern::SCHEME_HTTP, "http://*.example.com/*"));
1500
1501     expected.insert("*.google.com");
1502     expected.insert("*.example.com");
1503
1504     scoped_refptr<PermissionSet> perm_set(new PermissionSet(
1505         empty_perms, ManifestPermissionSet(),
1506         explicit_hosts, scriptable_hosts));
1507     EXPECT_EQ(expected,
1508               permission_message_util::GetDistinctHosts(
1509                   perm_set->effective_hosts(), true, true));
1510   }
1511
1512   {
1513     // We don't display warnings for file URLs because they are off by default.
1514     SCOPED_TRACE("file urls");
1515
1516     explicit_hosts.ClearPatterns();
1517     expected.clear();
1518
1519     explicit_hosts.AddPattern(
1520         URLPattern(URLPattern::SCHEME_FILE, "file:///*"));
1521
1522     EXPECT_EQ(expected,
1523               permission_message_util::GetDistinctHosts(
1524                   explicit_hosts, true, true));
1525   }
1526 }
1527
1528 TEST(PermissionsTest, GetDistinctHosts_ComIsBestRcd) {
1529   URLPatternSet explicit_hosts;
1530   explicit_hosts.AddPattern(
1531       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
1532   explicit_hosts.AddPattern(
1533       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
1534   explicit_hosts.AddPattern(
1535       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
1536   explicit_hosts.AddPattern(
1537       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
1538   explicit_hosts.AddPattern(
1539       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
1540   explicit_hosts.AddPattern(
1541       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
1542
1543   std::set<std::string> expected;
1544   expected.insert("www.foo.com");
1545   EXPECT_EQ(expected,
1546             permission_message_util::GetDistinctHosts(
1547                 explicit_hosts, true, true));
1548 }
1549
1550 TEST(PermissionsTest, GetDistinctHosts_NetIs2ndBestRcd) {
1551   URLPatternSet explicit_hosts;
1552   explicit_hosts.AddPattern(
1553       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
1554   explicit_hosts.AddPattern(
1555       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
1556   explicit_hosts.AddPattern(
1557       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
1558   explicit_hosts.AddPattern(
1559       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
1560   explicit_hosts.AddPattern(
1561       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
1562   // No http://www.foo.com/path
1563
1564   std::set<std::string> expected;
1565   expected.insert("www.foo.net");
1566   EXPECT_EQ(expected,
1567             permission_message_util::GetDistinctHosts(
1568                 explicit_hosts, true, true));
1569 }
1570
1571 TEST(PermissionsTest, GetDistinctHosts_OrgIs3rdBestRcd) {
1572   URLPatternSet explicit_hosts;
1573   explicit_hosts.AddPattern(
1574       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
1575   explicit_hosts.AddPattern(
1576       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
1577   explicit_hosts.AddPattern(
1578       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
1579   // No http://www.foo.net/path
1580   explicit_hosts.AddPattern(
1581       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
1582   // No http://www.foo.com/path
1583
1584   std::set<std::string> expected;
1585   expected.insert("www.foo.org");
1586   EXPECT_EQ(expected,
1587             permission_message_util::GetDistinctHosts(
1588                 explicit_hosts, true, true));
1589 }
1590
1591 TEST(PermissionsTest, GetDistinctHosts_FirstInListIs4thBestRcd) {
1592   URLPatternSet explicit_hosts;
1593   explicit_hosts.AddPattern(
1594       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
1595   // No http://www.foo.org/path
1596   explicit_hosts.AddPattern(
1597       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
1598   // No http://www.foo.net/path
1599   explicit_hosts.AddPattern(
1600       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
1601   // No http://www.foo.com/path
1602
1603   std::set<std::string> expected;
1604   expected.insert("www.foo.ca");
1605   EXPECT_EQ(expected,
1606             permission_message_util::GetDistinctHosts(
1607                 explicit_hosts, true, true));
1608 }
1609
1610 TEST(PermissionsTest, IsHostPrivilegeIncrease) {
1611   Manifest::Type type = Manifest::TYPE_EXTENSION;
1612   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
1613   ManifestPermissionSet empty_manifest_permissions;
1614   URLPatternSet elist1;
1615   URLPatternSet elist2;
1616   URLPatternSet slist1;
1617   URLPatternSet slist2;
1618   scoped_refptr<PermissionSet> set1;
1619   scoped_refptr<PermissionSet> set2;
1620   APIPermissionSet empty_perms;
1621   elist1.AddPattern(
1622       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
1623   elist1.AddPattern(
1624       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
1625
1626   // Test that the host order does not matter.
1627   elist2.AddPattern(
1628       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
1629   elist2.AddPattern(
1630       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
1631
1632   set1 = new PermissionSet(empty_perms, empty_manifest_permissions,
1633                            elist1, slist1);
1634   set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
1635                            elist2, slist2);
1636
1637   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1638   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
1639
1640   // Test that paths are ignored.
1641   elist2.ClearPatterns();
1642   elist2.AddPattern(
1643       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/*"));
1644   set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
1645                            elist2, slist2);
1646   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1647   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
1648
1649   // Test that RCDs are ignored.
1650   elist2.ClearPatterns();
1651   elist2.AddPattern(
1652       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/*"));
1653   set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
1654                            elist2, slist2);
1655   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1656   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
1657
1658   // Test that subdomain wildcards are handled properly.
1659   elist2.ClearPatterns();
1660   elist2.AddPattern(
1661       URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com.hk/*"));
1662   set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
1663                            elist2, slist2);
1664   EXPECT_TRUE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1665   // TODO(jstritar): Does not match subdomains properly. http://crbug.com/65337
1666   // EXPECT_FALSE(provider->IsPrivilegeIncrease(set2, set1, type));
1667
1668   // Test that different domains count as different hosts.
1669   elist2.ClearPatterns();
1670   elist2.AddPattern(
1671       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
1672   elist2.AddPattern(
1673       URLPattern(URLPattern::SCHEME_HTTP, "http://www.example.org/path"));
1674   set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
1675                            elist2, slist2);
1676   EXPECT_TRUE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1677   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
1678
1679   // Test that different subdomains count as different hosts.
1680   elist2.ClearPatterns();
1681   elist2.AddPattern(
1682       URLPattern(URLPattern::SCHEME_HTTP, "http://mail.google.com/*"));
1683   set2 = new PermissionSet(empty_perms, empty_manifest_permissions,
1684                            elist2, slist2);
1685   EXPECT_TRUE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1686   EXPECT_TRUE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
1687
1688   // Test that platform apps do not have host permissions increases.
1689   type = Manifest::TYPE_PLATFORM_APP;
1690   EXPECT_FALSE(provider->IsPrivilegeIncrease(set1.get(), set2.get(), type));
1691   EXPECT_FALSE(provider->IsPrivilegeIncrease(set2.get(), set1.get(), type));
1692 }
1693
1694 TEST(PermissionsTest, GetAPIsAsStrings) {
1695   APIPermissionSet apis;
1696   URLPatternSet empty_set;
1697
1698   apis.insert(APIPermission::kProxy);
1699   apis.insert(APIPermission::kBackground);
1700   apis.insert(APIPermission::kNotifications);
1701   apis.insert(APIPermission::kTab);
1702
1703   scoped_refptr<PermissionSet> perm_set = new PermissionSet(
1704       apis, ManifestPermissionSet(), empty_set, empty_set);
1705   std::set<std::string> api_names = perm_set->GetAPIsAsStrings();
1706
1707   // The result is correct if it has the same number of elements
1708   // and we can convert it back to the id set.
1709   EXPECT_EQ(4u, api_names.size());
1710   EXPECT_EQ(apis,
1711             PermissionsInfo::GetInstance()->GetAllByName(api_names));
1712 }
1713
1714 TEST(PermissionsTest, IsEmpty) {
1715   APIPermissionSet empty_apis;
1716   URLPatternSet empty_extent;
1717
1718   scoped_refptr<PermissionSet> empty = new PermissionSet();
1719   EXPECT_TRUE(empty->IsEmpty());
1720   scoped_refptr<PermissionSet> perm_set;
1721
1722   perm_set = new PermissionSet(empty_apis, ManifestPermissionSet(),
1723                                empty_extent, empty_extent);
1724   EXPECT_TRUE(perm_set->IsEmpty());
1725
1726   APIPermissionSet non_empty_apis;
1727   non_empty_apis.insert(APIPermission::kBackground);
1728   perm_set = new PermissionSet(non_empty_apis, ManifestPermissionSet(),
1729                                empty_extent, empty_extent);
1730   EXPECT_FALSE(perm_set->IsEmpty());
1731
1732   // Try non standard host
1733   URLPatternSet non_empty_extent;
1734   AddPattern(&non_empty_extent, "http://www.google.com/*");
1735
1736   perm_set = new PermissionSet(empty_apis, ManifestPermissionSet(),
1737                                non_empty_extent, empty_extent);
1738   EXPECT_FALSE(perm_set->IsEmpty());
1739
1740   perm_set = new PermissionSet(empty_apis, ManifestPermissionSet(),
1741                                empty_extent, non_empty_extent);
1742   EXPECT_FALSE(perm_set->IsEmpty());
1743 }
1744
1745 TEST(PermissionsTest, ImpliedPermissions) {
1746   URLPatternSet empty_extent;
1747   APIPermissionSet apis;
1748   apis.insert(APIPermission::kFileBrowserHandler);
1749   EXPECT_EQ(1U, apis.size());
1750
1751   scoped_refptr<PermissionSet> perm_set;
1752   perm_set = new PermissionSet(apis, ManifestPermissionSet(),
1753                                empty_extent, empty_extent);
1754   EXPECT_EQ(2U, perm_set->apis().size());
1755 }
1756
1757 TEST(PermissionsTest, SyncFileSystemPermission) {
1758   scoped_refptr<Extension> extension = LoadManifest(
1759       "permissions", "sync_file_system.json");
1760   APIPermissionSet apis;
1761   apis.insert(APIPermission::kSyncFileSystem);
1762   EXPECT_TRUE(extension->is_platform_app());
1763   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
1764       APIPermission::kSyncFileSystem));
1765   EXPECT_TRUE(
1766       VerifyOnePermissionMessage(extension->permissions_data(),
1767                                  "Store data in your Google Drive account"));
1768 }
1769
1770 // Make sure that we don't crash when we're trying to show the permissions
1771 // even though chrome://thumb (and everything that's not chrome://favicon with
1772 // a chrome:// scheme) is not a valid permission.
1773 // More details here: crbug/246314.
1774 TEST(PermissionsTest, ChromeURLs) {
1775   URLPatternSet allowed_hosts;
1776   allowed_hosts.AddPattern(
1777       URLPattern(URLPattern::SCHEME_ALL, "http://www.google.com/"));
1778   allowed_hosts.AddPattern(
1779       URLPattern(URLPattern::SCHEME_ALL, "chrome://favicon/"));
1780   allowed_hosts.AddPattern(
1781       URLPattern(URLPattern::SCHEME_ALL, "chrome://thumb/"));
1782   scoped_refptr<PermissionSet> permissions(
1783       new PermissionSet(APIPermissionSet(), ManifestPermissionSet(),
1784                         allowed_hosts, URLPatternSet()));
1785   PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
1786       permissions.get(), Manifest::TYPE_EXTENSION);
1787   PermissionMessageProvider::Get()->GetCoalescedPermissionMessages(
1788       PermissionMessageProvider::Get()->GetAllPermissionIDs(
1789           permissions.get(), Manifest::TYPE_EXTENSION));
1790 }
1791
1792 TEST(PermissionsTest, IsPrivilegeIncrease_DeclarativeWebRequest) {
1793   scoped_refptr<Extension> extension(
1794       LoadManifest("permissions", "permissions_all_urls.json"));
1795   scoped_refptr<const PermissionSet> permissions(
1796       extension->permissions_data()->active_permissions());
1797
1798   scoped_refptr<Extension> extension_dwr(
1799       LoadManifest("permissions", "web_request_all_host_permissions.json"));
1800   scoped_refptr<const PermissionSet> permissions_dwr(
1801       extension_dwr->permissions_data()->active_permissions());
1802
1803   EXPECT_FALSE(PermissionMessageProvider::Get()->
1804                    IsPrivilegeIncrease(permissions.get(),
1805                                        permissions_dwr.get(),
1806                                        extension->GetType()));
1807 }
1808
1809 }  // namespace extensions