chrome/browser/extensions/extension_prefs_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 "chrome/browser/extensions/extension_prefs_unittest.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/path_service.h"
  10 #include "base/prefs/mock_pref_change_callback.h"
  11 #include "base/prefs/pref_change_registrar.h"
  12 #include "base/prefs/scoped_user_pref_update.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/time/time.h"
  17 #include "base/values.h"
  18 #include "chrome/browser/prefs/pref_service_syncable.h"
  19 #include "chrome/common/chrome_paths.h"
  20 #include "components/pref_registry/pref_registry_syncable.h"
  21 #include "content/public/browser/notification_details.h"
  22 #include "content/public/browser/notification_source.h"
  23 #include "content/public/test/mock_notification_observer.h"
  24 #include "extensions/browser/extension_pref_value_map.h"
  25 #include "extensions/browser/extension_prefs.h"
  26 #include "extensions/browser/install_flag.h"
  27 #include "extensions/common/extension.h"
  28 #include "extensions/common/extension_builder.h"
  29 #include "extensions/common/manifest_constants.h"
  30 #include "extensions/common/permissions/permission_set.h"
  31 #include "extensions/common/permissions/permissions_info.h"
  32 #include "sync/api/string_ordinal.h"
  33
  34 using base::Time;
  35 using base::TimeDelta;
  36 using content::BrowserThread;
  37
  38 namespace extensions {
  39
  40 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
  41   int schemes = URLPattern::SCHEME_ALL;
  42   extent->AddPattern(URLPattern(schemes, pattern));
  43 }
  44
  45 ExtensionPrefsTest::ExtensionPrefsTest()
  46     : ui_thread_(BrowserThread::UI, &message_loop_),
  47       prefs_(message_loop_.message_loop_proxy().get()) {}
  48
  49 ExtensionPrefsTest::~ExtensionPrefsTest() {
  50 }
  51
  52 void ExtensionPrefsTest::RegisterPreferences(
  53     user_prefs::PrefRegistrySyncable* registry) {}
  54
  55 void ExtensionPrefsTest::SetUp() {
  56   RegisterPreferences(prefs_.pref_registry().get());
  57   Initialize();
  58 }
  59
  60 void ExtensionPrefsTest::TearDown() {
  61   Verify();
  62
  63   // Reset ExtensionPrefs, and re-verify.
  64   prefs_.ResetPrefRegistry();
  65   RegisterPreferences(prefs_.pref_registry().get());
  66   prefs_.RecreateExtensionPrefs();
  67   Verify();
  68   prefs_.pref_service()->CommitPendingWrite();
  69   message_loop_.RunUntilIdle();
  70 }
  71
  72 // Tests the LastPingDay/SetLastPingDay functions.
  73 class ExtensionPrefsLastPingDay : public ExtensionPrefsTest {
  74  public:
  75   ExtensionPrefsLastPingDay()
  76       : extension_time_(Time::Now() - TimeDelta::FromHours(4)),
  77         blacklist_time_(Time::Now() - TimeDelta::FromHours(2)) {}
  78
  79   void Initialize() override {
  80     extension_id_ = prefs_.AddExtensionAndReturnId("last_ping_day");
  81     EXPECT_TRUE(prefs()->LastPingDay(extension_id_).is_null());
  82     prefs()->SetLastPingDay(extension_id_, extension_time_);
  83     prefs()->SetBlacklistLastPingDay(blacklist_time_);
  84   }
  85
  86   void Verify() override {
  87     Time result = prefs()->LastPingDay(extension_id_);
  88     EXPECT_FALSE(result.is_null());
  89     EXPECT_TRUE(result == extension_time_);
  90     result = prefs()->BlacklistLastPingDay();
  91     EXPECT_FALSE(result.is_null());
  92     EXPECT_TRUE(result == blacklist_time_);
  93   }
  94
  95  private:
  96   Time extension_time_;
  97   Time blacklist_time_;
  98   std::string extension_id_;
  99 };
 100 TEST_F(ExtensionPrefsLastPingDay, LastPingDay) {}
 101
 102 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 103 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {
 104  public:
 105   void Initialize() override {
 106     list_.push_back(prefs_.AddExtensionAndReturnId("1"));
 107     list_.push_back(prefs_.AddExtensionAndReturnId("2"));
 108     list_.push_back(prefs_.AddExtensionAndReturnId("3"));
 109     ExtensionIdList before_list = prefs()->GetToolbarOrder();
 110     EXPECT_TRUE(before_list.empty());
 111     prefs()->SetToolbarOrder(list_);
 112   }
 113
 114   void Verify() override {
 115     ExtensionIdList result = prefs()->GetToolbarOrder();
 116     ASSERT_EQ(list_, result);
 117   }
 118
 119  private:
 120   ExtensionIdList list_;
 121 };
 122 TEST_F(ExtensionPrefsToolbarOrder, ToolbarOrder) {}
 123
 124 // Tests the IsExtensionDisabled/SetExtensionState functions.
 125 class ExtensionPrefsExtensionState : public ExtensionPrefsTest {
 126  public:
 127   void Initialize() override {
 128     extension = prefs_.AddExtension("test");
 129     prefs()->SetExtensionState(extension->id(), Extension::DISABLED);
 130   }
 131
 132   void Verify() override {
 133     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension->id()));
 134   }
 135
 136  private:
 137   scoped_refptr<Extension> extension;
 138 };
 139 TEST_F(ExtensionPrefsExtensionState, ExtensionState) {}
 140
 141 class ExtensionPrefsEscalatePermissions : public ExtensionPrefsTest {
 142  public:
 143   void Initialize() override {
 144     extension = prefs_.AddExtension("test");
 145     prefs()->AddDisableReason(extension->id(),
 146                               Extension::DISABLE_PERMISSIONS_INCREASE);
 147   }
 148
 149   void Verify() override {
 150     EXPECT_TRUE(prefs()->DidExtensionEscalatePermissions(extension->id()));
 151   }
 152
 153  private:
 154   scoped_refptr<Extension> extension;
 155 };
 156 TEST_F(ExtensionPrefsEscalatePermissions, EscalatePermissions) {}
 157
 158 // Tests the AddGrantedPermissions / GetGrantedPermissions functions.
 159 class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
 160  public:
 161   void Initialize() override {
 162     const APIPermissionInfo* permission_info =
 163       PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 164
 165     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 166
 167     api_perm_set1_.insert(APIPermission::kTab);
 168     api_perm_set1_.insert(APIPermission::kBookmark);
 169     scoped_ptr<APIPermission> permission(
 170         permission_info->CreateAPIPermission());
 171     {
 172       scoped_ptr<base::ListValue> value(new base::ListValue());
 173       value->Append(new base::StringValue("tcp-connect:*.example.com:80"));
 174       value->Append(new base::StringValue("udp-bind::8080"));
 175       value->Append(new base::StringValue("udp-send-to::8888"));
 176       ASSERT_TRUE(permission->FromValue(value.get(), NULL, NULL));
 177     }
 178     api_perm_set1_.insert(permission.release());
 179
 180     api_perm_set2_.insert(APIPermission::kHistory);
 181
 182     AddPattern(&ehost_perm_set1_, "http://*.google.com/*");
 183     AddPattern(&ehost_perm_set1_, "http://example.com/*");
 184     AddPattern(&ehost_perm_set1_, "chrome://favicon/*");
 185
 186     AddPattern(&ehost_perm_set2_, "https://*.google.com/*");
 187     // with duplicate:
 188     AddPattern(&ehost_perm_set2_, "http://*.google.com/*");
 189
 190     AddPattern(&shost_perm_set1_, "http://reddit.com/r/test/*");
 191     AddPattern(&shost_perm_set2_, "http://reddit.com/r/test/*");
 192     AddPattern(&shost_perm_set2_, "http://somesite.com/*");
 193     AddPattern(&shost_perm_set2_, "http://example.com/*");
 194
 195     APIPermissionSet expected_apis = api_perm_set1_;
 196
 197     AddPattern(&ehost_permissions_, "http://*.google.com/*");
 198     AddPattern(&ehost_permissions_, "http://example.com/*");
 199     AddPattern(&ehost_permissions_, "chrome://favicon/*");
 200     AddPattern(&ehost_permissions_, "https://*.google.com/*");
 201
 202     AddPattern(&shost_permissions_, "http://reddit.com/r/test/*");
 203     AddPattern(&shost_permissions_, "http://somesite.com/*");
 204     AddPattern(&shost_permissions_, "http://example.com/*");
 205
 206     APIPermissionSet empty_set;
 207     ManifestPermissionSet empty_manifest_permissions;
 208     URLPatternSet empty_extent;
 209     scoped_refptr<PermissionSet> permissions;
 210     scoped_refptr<PermissionSet> granted_permissions;
 211
 212     // Make sure both granted api and host permissions start empty.
 213     granted_permissions =
 214         prefs()->GetGrantedPermissions(extension_id_);
 215     EXPECT_TRUE(granted_permissions->IsEmpty());
 216
 217     permissions = new PermissionSet(
 218         api_perm_set1_, empty_manifest_permissions, empty_extent, empty_extent);
 219
 220     // Add part of the api permissions.
 221     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
 222     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
 223     EXPECT_TRUE(granted_permissions.get());
 224     EXPECT_FALSE(granted_permissions->IsEmpty());
 225     EXPECT_EQ(expected_apis, granted_permissions->apis());
 226     EXPECT_TRUE(granted_permissions->effective_hosts().is_empty());
 227     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
 228     granted_permissions = NULL;
 229
 230     // Add part of the explicit host permissions.
 231     permissions = new PermissionSet(
 232         empty_set, empty_manifest_permissions, ehost_perm_set1_, empty_extent);
 233     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
 234     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
 235     EXPECT_FALSE(granted_permissions->IsEmpty());
 236     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
 237     EXPECT_EQ(expected_apis, granted_permissions->apis());
 238     EXPECT_EQ(ehost_perm_set1_,
 239               granted_permissions->explicit_hosts());
 240     EXPECT_EQ(ehost_perm_set1_,
 241               granted_permissions->effective_hosts());
 242
 243     // Add part of the scriptable host permissions.
 244     permissions = new PermissionSet(
 245         empty_set, empty_manifest_permissions, empty_extent, shost_perm_set1_);
 246     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
 247     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
 248     EXPECT_FALSE(granted_permissions->IsEmpty());
 249     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
 250     EXPECT_EQ(expected_apis, granted_permissions->apis());
 251     EXPECT_EQ(ehost_perm_set1_,
 252               granted_permissions->explicit_hosts());
 253     EXPECT_EQ(shost_perm_set1_,
 254               granted_permissions->scriptable_hosts());
 255
 256     URLPatternSet::CreateUnion(ehost_perm_set1_, shost_perm_set1_,
 257                                &effective_permissions_);
 258     EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
 259
 260     // Add the rest of the permissions.
 261     permissions = new PermissionSet(
 262         api_perm_set2_, empty_manifest_permissions,
 263         ehost_perm_set2_, shost_perm_set2_);
 264
 265     APIPermissionSet::Union(expected_apis, api_perm_set2_, &api_permissions_);
 266
 267     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
 268     granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
 269     EXPECT_TRUE(granted_permissions.get());
 270     EXPECT_FALSE(granted_permissions->IsEmpty());
 271     EXPECT_EQ(api_permissions_, granted_permissions->apis());
 272     EXPECT_EQ(ehost_permissions_,
 273               granted_permissions->explicit_hosts());
 274     EXPECT_EQ(shost_permissions_,
 275               granted_permissions->scriptable_hosts());
 276     effective_permissions_.ClearPatterns();
 277     URLPatternSet::CreateUnion(ehost_permissions_, shost_permissions_,
 278                                &effective_permissions_);
 279     EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
 280   }
 281
 282   void Verify() override {
 283     scoped_refptr<PermissionSet> permissions(
 284         prefs()->GetGrantedPermissions(extension_id_));
 285     EXPECT_TRUE(permissions.get());
 286     EXPECT_FALSE(permissions->HasEffectiveFullAccess());
 287     EXPECT_EQ(api_permissions_, permissions->apis());
 288     EXPECT_EQ(ehost_permissions_,
 289               permissions->explicit_hosts());
 290     EXPECT_EQ(shost_permissions_,
 291               permissions->scriptable_hosts());
 292   }
 293
 294  private:
 295   std::string extension_id_;
 296   APIPermissionSet api_perm_set1_;
 297   APIPermissionSet api_perm_set2_;
 298   URLPatternSet ehost_perm_set1_;
 299   URLPatternSet ehost_perm_set2_;
 300   URLPatternSet shost_perm_set1_;
 301   URLPatternSet shost_perm_set2_;
 302
 303   APIPermissionSet api_permissions_;
 304   URLPatternSet ehost_permissions_;
 305   URLPatternSet shost_permissions_;
 306   URLPatternSet effective_permissions_;
 307 };
 308 TEST_F(ExtensionPrefsGrantedPermissions, GrantedPermissions) {}
 309
 310 // Tests the SetActivePermissions / GetActivePermissions functions.
 311 class ExtensionPrefsActivePermissions : public ExtensionPrefsTest {
 312  public:
 313   void Initialize() override {
 314     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 315
 316     APIPermissionSet api_perms;
 317     api_perms.insert(APIPermission::kTab);
 318     api_perms.insert(APIPermission::kBookmark);
 319     api_perms.insert(APIPermission::kHistory);
 320
 321     ManifestPermissionSet empty_manifest_permissions;
 322
 323     URLPatternSet ehosts;
 324     AddPattern(&ehosts, "http://*.google.com/*");
 325     AddPattern(&ehosts, "http://example.com/*");
 326     AddPattern(&ehosts, "chrome://favicon/*");
 327
 328     URLPatternSet shosts;
 329     AddPattern(&shosts, "https://*.google.com/*");
 330     AddPattern(&shosts, "http://reddit.com/r/test/*");
 331
 332     active_perms_ = new PermissionSet(
 333         api_perms, empty_manifest_permissions, ehosts, shosts);
 334
 335     // Make sure the active permissions start empty.
 336     scoped_refptr<PermissionSet> active(
 337         prefs()->GetActivePermissions(extension_id_));
 338     EXPECT_TRUE(active->IsEmpty());
 339
 340     // Set the active permissions.
 341     prefs()->SetActivePermissions(extension_id_, active_perms_.get());
 342     active = prefs()->GetActivePermissions(extension_id_);
 343     EXPECT_EQ(active_perms_->apis(), active->apis());
 344     EXPECT_EQ(active_perms_->explicit_hosts(), active->explicit_hosts());
 345     EXPECT_EQ(active_perms_->scriptable_hosts(), active->scriptable_hosts());
 346     EXPECT_EQ(*active_perms_.get(), *active.get());
 347   }
 348
 349   void Verify() override {
 350     scoped_refptr<PermissionSet> permissions(
 351         prefs()->GetActivePermissions(extension_id_));
 352     EXPECT_EQ(*active_perms_.get(), *permissions.get());
 353   }
 354
 355  private:
 356   std::string extension_id_;
 357   scoped_refptr<PermissionSet> active_perms_;
 358 };
 359 TEST_F(ExtensionPrefsActivePermissions, SetAndGetActivePermissions) {}
 360
 361 // Tests the GetVersionString function.
 362 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
 363  public:
 364   void Initialize() override {
 365     extension = prefs_.AddExtension("test");
 366     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
 367     prefs()->OnExtensionUninstalled(extension->id(),
 368                                     Manifest::INTERNAL, false);
 369   }
 370
 371   void Verify() override {
 372     EXPECT_EQ("", prefs()->GetVersionString(extension->id()));
 373   }
 374
 375  private:
 376   scoped_refptr<Extension> extension;
 377 };
 378 TEST_F(ExtensionPrefsVersionString, VersionString) {}
 379
 380 class ExtensionPrefsAcknowledgment : public ExtensionPrefsTest {
 381  public:
 382   void Initialize() override {
 383     not_installed_id_ = "pghjnghklobnfoidcldiidjjjhkeeaoi";
 384
 385     // Install some extensions.
 386     for (int i = 0; i < 5; i++) {
 387       std::string name = "test" + base::IntToString(i);
 388       extensions_.push_back(prefs_.AddExtension(name));
 389     }
 390     EXPECT_EQ(NULL,
 391               prefs()->GetInstalledExtensionInfo(not_installed_id_).get());
 392
 393     ExtensionList::const_iterator iter;
 394     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
 395       std::string id = (*iter)->id();
 396       EXPECT_FALSE(prefs()->IsExternalExtensionAcknowledged(id));
 397       EXPECT_FALSE(prefs()->IsBlacklistedExtensionAcknowledged(id));
 398       if (external_id_.empty()) {
 399         external_id_ = id;
 400         continue;
 401       }
 402       if (blacklisted_id_.empty()) {
 403         blacklisted_id_ = id;
 404         continue;
 405       }
 406     }
 407     // For each type of acknowledgment, acknowledge one installed and one
 408     // not-installed extension id.
 409     prefs()->AcknowledgeExternalExtension(external_id_);
 410     prefs()->AcknowledgeBlacklistedExtension(blacklisted_id_);
 411     prefs()->AcknowledgeExternalExtension(not_installed_id_);
 412     prefs()->AcknowledgeBlacklistedExtension(not_installed_id_);
 413   }
 414
 415   void Verify() override {
 416     ExtensionList::const_iterator iter;
 417     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
 418       std::string id = (*iter)->id();
 419       if (id == external_id_) {
 420         EXPECT_TRUE(prefs()->IsExternalExtensionAcknowledged(id));
 421       } else {
 422         EXPECT_FALSE(prefs()->IsExternalExtensionAcknowledged(id));
 423       }
 424       if (id == blacklisted_id_) {
 425         EXPECT_TRUE(prefs()->IsBlacklistedExtensionAcknowledged(id));
 426       } else {
 427         EXPECT_FALSE(prefs()->IsBlacklistedExtensionAcknowledged(id));
 428       }
 429     }
 430     EXPECT_TRUE(prefs()->IsExternalExtensionAcknowledged(not_installed_id_));
 431     EXPECT_TRUE(prefs()->IsBlacklistedExtensionAcknowledged(not_installed_id_));
 432   }
 433
 434  private:
 435   ExtensionList extensions_;
 436
 437   std::string not_installed_id_;
 438   std::string external_id_;
 439   std::string blacklisted_id_;
 440 };
 441 TEST_F(ExtensionPrefsAcknowledgment, Acknowledgment) {}
 442
 443 // Tests the idle install information functions.
 444 class ExtensionPrefsDelayedInstallInfo : public ExtensionPrefsTest {
 445  public:
 446   // Sets idle install information for one test extension.
 447   void SetIdleInfo(const std::string& id, int num) {
 448     base::DictionaryValue manifest;
 449     manifest.SetString(manifest_keys::kName, "test");
 450     manifest.SetString(manifest_keys::kVersion, "1." + base::IntToString(num));
 451     base::FilePath path =
 452         prefs_.extensions_dir().AppendASCII(base::IntToString(num));
 453     std::string errors;
 454     scoped_refptr<Extension> extension = Extension::Create(
 455         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
 456     ASSERT_TRUE(extension.get()) << errors;
 457     ASSERT_EQ(id, extension->id());
 458     prefs()->SetDelayedInstallInfo(extension.get(),
 459                                    Extension::ENABLED,
 460                                    kInstallFlagNone,
 461                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
 462                                    syncer::StringOrdinal(),
 463                                    std::string());
 464   }
 465
 466   // Verifies that we get back expected idle install information previously
 467   // set by SetIdleInfo.
 468   void VerifyIdleInfo(const std::string& id, int num) {
 469     scoped_ptr<ExtensionInfo> info(prefs()->GetDelayedInstallInfo(id));
 470     ASSERT_TRUE(info);
 471     std::string version;
 472     ASSERT_TRUE(info->extension_manifest->GetString("version", &version));
 473     ASSERT_EQ("1." + base::IntToString(num), version);
 474     ASSERT_EQ(base::IntToString(num),
 475               info->extension_path.BaseName().MaybeAsASCII());
 476   }
 477
 478   bool HasInfoForId(ExtensionPrefs::ExtensionsInfo* info,
 479                     const std::string& id) {
 480     for (size_t i = 0; i < info->size(); ++i) {
 481       if (info->at(i)->extension_id == id)
 482         return true;
 483     }
 484     return false;
 485   }
 486
 487   void Initialize() override {
 488     PathService::Get(chrome::DIR_TEST_DATA, &basedir_);
 489     now_ = Time::Now();
 490     id1_ = prefs_.AddExtensionAndReturnId("1");
 491     id2_ = prefs_.AddExtensionAndReturnId("2");
 492     id3_ = prefs_.AddExtensionAndReturnId("3");
 493     id4_ = prefs_.AddExtensionAndReturnId("4");
 494
 495     // Set info for two extensions, then remove it.
 496     SetIdleInfo(id1_, 1);
 497     SetIdleInfo(id2_, 2);
 498     VerifyIdleInfo(id1_, 1);
 499     VerifyIdleInfo(id2_, 2);
 500     scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
 501         prefs()->GetAllDelayedInstallInfo());
 502     EXPECT_EQ(2u, info->size());
 503     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
 504     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
 505     prefs()->RemoveDelayedInstallInfo(id1_);
 506     prefs()->RemoveDelayedInstallInfo(id2_);
 507     info = prefs()->GetAllDelayedInstallInfo();
 508     EXPECT_TRUE(info->empty());
 509
 510     // Try getting/removing info for an id that used to have info set.
 511     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id1_));
 512     EXPECT_FALSE(prefs()->RemoveDelayedInstallInfo(id1_));
 513
 514     // Try getting/removing info for an id that has not yet had any info set.
 515     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
 516     EXPECT_FALSE(prefs()->RemoveDelayedInstallInfo(id3_));
 517
 518     // Set info for 4 extensions, then remove for one of them.
 519     SetIdleInfo(id1_, 1);
 520     SetIdleInfo(id2_, 2);
 521     SetIdleInfo(id3_, 3);
 522     SetIdleInfo(id4_, 4);
 523     VerifyIdleInfo(id1_, 1);
 524     VerifyIdleInfo(id2_, 2);
 525     VerifyIdleInfo(id3_, 3);
 526     VerifyIdleInfo(id4_, 4);
 527     prefs()->RemoveDelayedInstallInfo(id3_);
 528   }
 529
 530   void Verify() override {
 531     // Make sure the info for the 3 extensions we expect is present.
 532     scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
 533         prefs()->GetAllDelayedInstallInfo());
 534     EXPECT_EQ(3u, info->size());
 535     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
 536     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
 537     EXPECT_TRUE(HasInfoForId(info.get(), id4_));
 538     VerifyIdleInfo(id1_, 1);
 539     VerifyIdleInfo(id2_, 2);
 540     VerifyIdleInfo(id4_, 4);
 541
 542     // Make sure there isn't info the for the one extension id we removed.
 543     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
 544   }
 545
 546  protected:
 547   Time now_;
 548   base::FilePath basedir_;
 549   std::string id1_;
 550   std::string id2_;
 551   std::string id3_;
 552   std::string id4_;
 553 };
 554 TEST_F(ExtensionPrefsDelayedInstallInfo, DelayedInstallInfo) {}
 555
 556 // Tests the FinishDelayedInstallInfo function.
 557 class ExtensionPrefsFinishDelayedInstallInfo : public ExtensionPrefsTest {
 558  public:
 559   void Initialize() override {
 560     base::DictionaryValue dictionary;
 561     dictionary.SetString(manifest_keys::kName, "test");
 562     dictionary.SetString(manifest_keys::kVersion, "0.1");
 563     dictionary.SetString(manifest_keys::kBackgroundPage, "background.html");
 564     scoped_refptr<Extension> extension =
 565         prefs_.AddExtensionWithManifest(dictionary, Manifest::INTERNAL);
 566     id_ = extension->id();
 567
 568
 569     // Set idle info
 570     base::DictionaryValue manifest;
 571     manifest.SetString(manifest_keys::kName, "test");
 572     manifest.SetString(manifest_keys::kVersion, "0.2");
 573     scoped_ptr<base::ListValue> scripts(new base::ListValue);
 574     scripts->AppendString("test.js");
 575     manifest.Set(manifest_keys::kBackgroundScripts, scripts.release());
 576     base::FilePath path =
 577         prefs_.extensions_dir().AppendASCII("test_0.2");
 578     std::string errors;
 579     scoped_refptr<Extension> new_extension = Extension::Create(
 580         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id_, &errors);
 581     ASSERT_TRUE(new_extension.get()) << errors;
 582     ASSERT_EQ(id_, new_extension->id());
 583     prefs()->SetDelayedInstallInfo(new_extension.get(),
 584                                    Extension::ENABLED,
 585                                    kInstallFlagNone,
 586                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
 587                                    syncer::StringOrdinal(),
 588                                    "Param");
 589
 590     // Finish idle installation
 591     ASSERT_TRUE(prefs()->FinishDelayedInstallInfo(id_));
 592   }
 593
 594   void Verify() override {
 595     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id_));
 596     EXPECT_EQ(std::string("Param"), prefs()->GetInstallParam(id_));
 597
 598     const base::DictionaryValue* manifest;
 599     ASSERT_TRUE(prefs()->ReadPrefAsDictionary(id_, "manifest", &manifest));
 600     ASSERT_TRUE(manifest);
 601     std::string value;
 602     EXPECT_TRUE(manifest->GetString(manifest_keys::kName, &value));
 603     EXPECT_EQ("test", value);
 604     EXPECT_TRUE(manifest->GetString(manifest_keys::kVersion, &value));
 605     EXPECT_EQ("0.2", value);
 606     EXPECT_FALSE(manifest->GetString(manifest_keys::kBackgroundPage, &value));
 607     const base::ListValue* scripts;
 608     ASSERT_TRUE(manifest->GetList(manifest_keys::kBackgroundScripts, &scripts));
 609     EXPECT_EQ(1u, scripts->GetSize());
 610   }
 611
 612  protected:
 613   std::string id_;
 614 };
 615 TEST_F(ExtensionPrefsFinishDelayedInstallInfo, FinishDelayedInstallInfo) {}
 616
 617 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
 618  public:
 619   void Initialize() override {
 620     extension_ = prefs_.AddExtension("on_extension_installed");
 621     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
 622     prefs()->OnExtensionInstalled(extension_.get(),
 623                                   Extension::DISABLED,
 624                                   syncer::StringOrdinal(),
 625                                   "Param");
 626   }
 627
 628   void Verify() override {
 629     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension_->id()));
 630     EXPECT_EQ(std::string("Param"), prefs()->GetInstallParam(extension_->id()));
 631   }
 632
 633  private:
 634   scoped_refptr<Extension> extension_;
 635 };
 636 TEST_F(ExtensionPrefsOnExtensionInstalled,
 637        ExtensionPrefsOnExtensionInstalled) {}
 638
 639 class ExtensionPrefsAppDraggedByUser : public ExtensionPrefsTest {
 640  public:
 641   void Initialize() override {
 642     extension_ = prefs_.AddExtension("on_extension_installed");
 643     EXPECT_FALSE(prefs()->WasAppDraggedByUser(extension_->id()));
 644     prefs()->OnExtensionInstalled(extension_.get(),
 645                                   Extension::ENABLED,
 646                                   syncer::StringOrdinal(),
 647                                   std::string());
 648   }
 649
 650   void Verify() override {
 651     // Set the flag and see if it persisted.
 652     prefs()->SetAppDraggedByUser(extension_->id());
 653     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
 654
 655     // Make sure it doesn't change on consecutive calls.
 656     prefs()->SetAppDraggedByUser(extension_->id());
 657     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
 658   }
 659
 660  private:
 661   scoped_refptr<Extension> extension_;
 662 };
 663 TEST_F(ExtensionPrefsAppDraggedByUser, ExtensionPrefsAppDraggedByUser) {}
 664
 665 class ExtensionPrefsFlags : public ExtensionPrefsTest {
 666  public:
 667   void Initialize() override {
 668     {
 669       base::DictionaryValue dictionary;
 670       dictionary.SetString(manifest_keys::kName, "from_webstore");
 671       dictionary.SetString(manifest_keys::kVersion, "0.1");
 672       webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
 673           dictionary, Manifest::INTERNAL, Extension::FROM_WEBSTORE);
 674     }
 675
 676     {
 677       base::DictionaryValue dictionary;
 678       dictionary.SetString(manifest_keys::kName, "from_bookmark");
 679       dictionary.SetString(manifest_keys::kVersion, "0.1");
 680       bookmark_extension_ = prefs_.AddExtensionWithManifestAndFlags(
 681           dictionary, Manifest::INTERNAL, Extension::FROM_BOOKMARK);
 682     }
 683
 684     {
 685       base::DictionaryValue dictionary;
 686       dictionary.SetString(manifest_keys::kName, "was_installed_by_default");
 687       dictionary.SetString(manifest_keys::kVersion, "0.1");
 688       default_extension_ = prefs_.AddExtensionWithManifestAndFlags(
 689           dictionary,
 690           Manifest::INTERNAL,
 691           Extension::WAS_INSTALLED_BY_DEFAULT);
 692     }
 693
 694     {
 695       base::DictionaryValue dictionary;
 696       dictionary.SetString(manifest_keys::kName, "was_installed_by_oem");
 697       dictionary.SetString(manifest_keys::kVersion, "0.1");
 698       oem_extension_ = prefs_.AddExtensionWithManifestAndFlags(
 699           dictionary, Manifest::INTERNAL, Extension::WAS_INSTALLED_BY_OEM);
 700     }
 701   }
 702
 703   void Verify() override {
 704     EXPECT_TRUE(prefs()->IsFromWebStore(webstore_extension_->id()));
 705     EXPECT_FALSE(prefs()->IsFromBookmark(webstore_extension_->id()));
 706
 707     EXPECT_TRUE(prefs()->IsFromBookmark(bookmark_extension_->id()));
 708     EXPECT_FALSE(prefs()->IsFromWebStore(bookmark_extension_->id()));
 709
 710     EXPECT_TRUE(prefs()->WasInstalledByDefault(default_extension_->id()));
 711     EXPECT_TRUE(prefs()->WasInstalledByOem(oem_extension_->id()));
 712   }
 713
 714  private:
 715   scoped_refptr<Extension> webstore_extension_;
 716   scoped_refptr<Extension> bookmark_extension_;
 717   scoped_refptr<Extension> default_extension_;
 718   scoped_refptr<Extension> oem_extension_;
 719 };
 720 TEST_F(ExtensionPrefsFlags, ExtensionPrefsFlags) {}
 721
 722 PrefsPrepopulatedTestBase::PrefsPrepopulatedTestBase()
 723     : ExtensionPrefsTest() {
 724   base::DictionaryValue simple_dict;
 725   std::string error;
 726
 727   simple_dict.SetString(manifest_keys::kVersion, "1.0.0.0");
 728   simple_dict.SetString(manifest_keys::kName, "unused");
 729
 730   extension1_ = Extension::Create(
 731       prefs_.temp_dir().AppendASCII("ext1_"),
 732       Manifest::EXTERNAL_PREF,
 733       simple_dict,
 734       Extension::NO_FLAGS,
 735       &error);
 736   extension2_ = Extension::Create(
 737       prefs_.temp_dir().AppendASCII("ext2_"),
 738       Manifest::EXTERNAL_PREF,
 739       simple_dict,
 740       Extension::NO_FLAGS,
 741       &error);
 742   extension3_ = Extension::Create(
 743       prefs_.temp_dir().AppendASCII("ext3_"),
 744       Manifest::EXTERNAL_PREF,
 745       simple_dict,
 746       Extension::NO_FLAGS,
 747       &error);
 748   extension4_ = Extension::Create(
 749       prefs_.temp_dir().AppendASCII("ext4_"),
 750       Manifest::EXTERNAL_PREF,
 751       simple_dict,
 752       Extension::NO_FLAGS,
 753       &error);
 754
 755   for (size_t i = 0; i < kNumInstalledExtensions; ++i)
 756     installed_[i] = false;
 757 }
 758
 759 PrefsPrepopulatedTestBase::~PrefsPrepopulatedTestBase() {
 760 }
 761
 762 // Tests that blacklist state can be queried.
 763 class ExtensionPrefsBlacklistedExtensions : public ExtensionPrefsTest {
 764  public:
 765   ~ExtensionPrefsBlacklistedExtensions() override {}
 766
 767   void Initialize() override {
 768     extension_a_ = prefs_.AddExtension("a");
 769     extension_b_ = prefs_.AddExtension("b");
 770     extension_c_ = prefs_.AddExtension("c");
 771   }
 772
 773   void Verify() override {
 774     {
 775       ExtensionIdSet ids;
 776       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 777     }
 778     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
 779     {
 780       ExtensionIdSet ids;
 781       ids.insert(extension_a_->id());
 782       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 783     }
 784     prefs()->SetExtensionBlacklisted(extension_b_->id(), true);
 785     prefs()->SetExtensionBlacklisted(extension_c_->id(), true);
 786     {
 787       ExtensionIdSet ids;
 788       ids.insert(extension_a_->id());
 789       ids.insert(extension_b_->id());
 790       ids.insert(extension_c_->id());
 791       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 792     }
 793     prefs()->SetExtensionBlacklisted(extension_a_->id(), false);
 794     {
 795       ExtensionIdSet ids;
 796       ids.insert(extension_b_->id());
 797       ids.insert(extension_c_->id());
 798       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 799     }
 800     prefs()->SetExtensionBlacklisted(extension_b_->id(), false);
 801     prefs()->SetExtensionBlacklisted(extension_c_->id(), false);
 802     {
 803       ExtensionIdSet ids;
 804       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 805     }
 806
 807     // The interesting part: make sure that we're cleaning up after ourselves
 808     // when we're storing *just* the fact that the extension is blacklisted.
 809     std::string arbitrary_id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 810
 811     prefs()->SetExtensionBlacklisted(arbitrary_id, true);
 812     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
 813
 814     // (And make sure that the acknowledged bit is also cleared).
 815     prefs()->AcknowledgeBlacklistedExtension(arbitrary_id);
 816
 817     EXPECT_TRUE(prefs()->GetExtensionPref(arbitrary_id));
 818     {
 819       ExtensionIdSet ids;
 820       ids.insert(arbitrary_id);
 821       ids.insert(extension_a_->id());
 822       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 823     }
 824     prefs()->SetExtensionBlacklisted(arbitrary_id, false);
 825     prefs()->SetExtensionBlacklisted(extension_a_->id(), false);
 826     EXPECT_FALSE(prefs()->GetExtensionPref(arbitrary_id));
 827     {
 828       ExtensionIdSet ids;
 829       EXPECT_EQ(ids, prefs()->GetBlacklistedExtensions());
 830     }
 831   }
 832
 833  private:
 834   scoped_refptr<const Extension> extension_a_;
 835   scoped_refptr<const Extension> extension_b_;
 836   scoped_refptr<const Extension> extension_c_;
 837 };
 838 TEST_F(ExtensionPrefsBlacklistedExtensions,
 839        ExtensionPrefsBlacklistedExtensions) {}
 840
 841 // Tests the blacklist state. Old "blacklist" preference should take precedence
 842 // over new "blacklist_state".
 843 class ExtensionPrefsBlacklistState : public ExtensionPrefsTest {
 844  public:
 845   ~ExtensionPrefsBlacklistState() override {}
 846
 847   void Initialize() override { extension_a_ = prefs_.AddExtension("a"); }
 848
 849   void Verify() override {
 850     ExtensionIdSet empty_ids;
 851     EXPECT_EQ(empty_ids, prefs()->GetBlacklistedExtensions());
 852
 853     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
 854     EXPECT_EQ(BLACKLISTED_MALWARE,
 855               prefs()->GetExtensionBlacklistState(extension_a_->id()));
 856
 857     prefs()->SetExtensionBlacklistState(extension_a_->id(),
 858                                         BLACKLISTED_POTENTIALLY_UNWANTED);
 859     EXPECT_EQ(BLACKLISTED_POTENTIALLY_UNWANTED,
 860               prefs()->GetExtensionBlacklistState(extension_a_->id()));
 861     EXPECT_FALSE(prefs()->IsExtensionBlacklisted(extension_a_->id()));
 862     EXPECT_EQ(empty_ids, prefs()->GetBlacklistedExtensions());
 863
 864     prefs()->SetExtensionBlacklisted(extension_a_->id(), true);
 865     EXPECT_TRUE(prefs()->IsExtensionBlacklisted(extension_a_->id()));
 866     EXPECT_EQ(BLACKLISTED_MALWARE,
 867               prefs()->GetExtensionBlacklistState(extension_a_->id()));
 868     EXPECT_EQ(1u, prefs()->GetBlacklistedExtensions().size());
 869
 870     prefs()->SetExtensionBlacklistState(extension_a_->id(),
 871                                         NOT_BLACKLISTED);
 872     EXPECT_EQ(NOT_BLACKLISTED,
 873               prefs()->GetExtensionBlacklistState(extension_a_->id()));
 874     EXPECT_FALSE(prefs()->IsExtensionBlacklisted(extension_a_->id()));
 875     EXPECT_EQ(empty_ids, prefs()->GetBlacklistedExtensions());
 876   }
 877
 878  private:
 879   scoped_refptr<const Extension> extension_a_;
 880 };
 881 TEST_F(ExtensionPrefsBlacklistState, ExtensionPrefsBlacklistState) {}
 882
 883 // Tests clearing the last launched preference.
 884 class ExtensionPrefsClearLastLaunched : public ExtensionPrefsTest {
 885  public:
 886   ~ExtensionPrefsClearLastLaunched() override {}
 887
 888   void Initialize() override {
 889     extension_a_ = prefs_.AddExtension("a");
 890     extension_b_ = prefs_.AddExtension("b");
 891   }
 892
 893   void Verify() override {
 894     // Set last launched times for each extension.
 895     prefs()->SetLastLaunchTime(extension_a_->id(), base::Time::Now());
 896     prefs()->SetLastLaunchTime(extension_b_->id(), base::Time::Now());
 897
 898     // Also set some other preference for one of the extensions.
 899     prefs()->SetAllowFileAccess(extension_a_->id(), true);
 900
 901     // Now clear the launch times.
 902     prefs()->ClearLastLaunchTimes();
 903
 904     // All launch times should be gone.
 905     EXPECT_EQ(base::Time(), prefs()->GetLastLaunchTime(extension_a_->id()));
 906     EXPECT_EQ(base::Time(), prefs()->GetLastLaunchTime(extension_b_->id()));
 907
 908     // Other preferences should be untouched.
 909     EXPECT_TRUE(prefs()->AllowFileAccess(extension_a_->id()));
 910   }
 911
 912  private:
 913   scoped_refptr<const Extension> extension_a_;
 914   scoped_refptr<const Extension> extension_b_;
 915 };
 916 TEST_F(ExtensionPrefsClearLastLaunched, ExtensionPrefsClearLastLaunched) {}
 917
 918 class ExtensionPrefsComponentExtension : public ExtensionPrefsTest {
 919  public:
 920   ~ExtensionPrefsComponentExtension() override {}
 921   void Initialize() override {
 922     // Adding a component extension.
 923     component_extension_ =
 924         ExtensionBuilder()
 925             .SetManifest(DictionaryBuilder()
 926                              .Set(manifest_keys::kName, "a")
 927                              .Set(manifest_keys::kVersion, "0.1"))
 928             .SetLocation(Manifest::COMPONENT)
 929             .SetPath(prefs_.extensions_dir().AppendASCII("a"))
 930             .Build();
 931     prefs_.AddExtension(component_extension_.get());
 932
 933     // Adding a non component extension.
 934     no_component_extension_ =
 935         ExtensionBuilder()
 936             .SetManifest(DictionaryBuilder()
 937                              .Set(manifest_keys::kName, "b")
 938                              .Set(manifest_keys::kVersion, "0.1"))
 939             .SetLocation(Manifest::INTERNAL)
 940             .SetPath(prefs_.extensions_dir().AppendASCII("b"))
 941             .Build();
 942     prefs_.AddExtension(no_component_extension_.get());
 943
 944     APIPermissionSet api_perms;
 945     api_perms.insert(APIPermission::kTab);
 946     api_perms.insert(APIPermission::kBookmark);
 947     api_perms.insert(APIPermission::kHistory);
 948
 949     ManifestPermissionSet empty_manifest_permissions;
 950
 951     URLPatternSet ehosts, shosts;
 952     AddPattern(&shosts, "chrome://print/*");
 953
 954     active_perms_ = new PermissionSet(api_perms, empty_manifest_permissions,
 955                                       ehosts, shosts);
 956     // Set the active permissions.
 957     prefs()->SetActivePermissions(component_extension_->id(),
 958                                   active_perms_.get());
 959     prefs()->SetActivePermissions(no_component_extension_->id(),
 960                                   active_perms_.get());
 961   }
 962
 963   void Verify() override {
 964     // Component extension can access chrome://print/*.
 965     scoped_refptr<PermissionSet> component_permissions(
 966         prefs()->GetActivePermissions(component_extension_->id()));
 967     EXPECT_EQ(1u, component_permissions->scriptable_hosts().size());
 968
 969     // Non Component extension can not access chrome://print/*.
 970     scoped_refptr<PermissionSet> no_component_permissions(
 971         prefs()->GetActivePermissions(no_component_extension_->id()));
 972     EXPECT_EQ(0u, no_component_permissions->scriptable_hosts().size());
 973
 974     // |URLPattern::SCHEME_CHROMEUI| scheme will be added in valid_schemes for
 975     // component extensions.
 976     URLPatternSet scriptable_hosts;
 977     std::string pref_key = "active_permissions.scriptable_host";
 978     int valid_schemes = URLPattern::SCHEME_ALL & ~URLPattern::SCHEME_CHROMEUI;
 979
 980     EXPECT_TRUE(prefs()->ReadPrefAsURLPatternSet(component_extension_->id(),
 981                                                  pref_key, &scriptable_hosts,
 982                                                  valid_schemes));
 983
 984     EXPECT_FALSE(prefs()->ReadPrefAsURLPatternSet(no_component_extension_->id(),
 985                                                   pref_key, &scriptable_hosts,
 986                                                   valid_schemes));
 987   }
 988
 989  private:
 990   scoped_refptr<PermissionSet> active_perms_;
 991   scoped_refptr<Extension> component_extension_;
 992   scoped_refptr<Extension> no_component_extension_;
 993 };
 994 TEST_F(ExtensionPrefsComponentExtension, ExtensionPrefsComponentExtension) {
 995 }
 996
 997 }  // namespace extensions