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