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