src/chrome/browser/extensions/extension_service_unittest.cc

   1 // Copyright (c) 2013 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 <algorithm>
   6 #include <set>
   7 #include <vector>
   8
   9 #include "base/at_exit.h"
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/command_line.h"
  13 #include "base/files/file_enumerator.h"
  14 #include "base/files/file_util.h"
  15 #include "base/files/scoped_temp_dir.h"
  16 #include "base/json/json_file_value_serializer.h"
  17 #include "base/json/json_reader.h"
  18 #include "base/json/json_string_value_serializer.h"
  19 #include "base/memory/scoped_ptr.h"
  20 #include "base/memory/weak_ptr.h"
  21 #include "base/message_loop/message_loop.h"
  22 #include "base/prefs/scoped_user_pref_update.h"
  23 #include "base/stl_util.h"
  24 #include "base/strings/string16.h"
  25 #include "base/strings/string_number_conversions.h"
  26 #include "base/strings/string_util.h"
  27 #include "base/strings/utf_string_conversions.h"
  28 #include "base/version.h"
  29 #include "chrome/browser/browser_process.h"
  30 #include "chrome/browser/chrome_notification_types.h"
  31 #include "chrome/browser/extensions/app_sync_data.h"
  32 #include "chrome/browser/extensions/blacklist.h"
  33 #include "chrome/browser/extensions/chrome_app_sorting.h"
  34 #include "chrome/browser/extensions/component_loader.h"
  35 #include "chrome/browser/extensions/crx_installer.h"
  36 #include "chrome/browser/extensions/default_apps.h"
  37 #include "chrome/browser/extensions/extension_creator.h"
  38 #include "chrome/browser/extensions/extension_error_reporter.h"
  39 #include "chrome/browser/extensions/extension_error_ui.h"
  40 #include "chrome/browser/extensions/extension_management_test_util.h"
  41 #include "chrome/browser/extensions/extension_notification_observer.h"
  42 #include "chrome/browser/extensions/extension_service.h"
  43 #include "chrome/browser/extensions/extension_service_test_base.h"
  44 #include "chrome/browser/extensions/extension_special_storage_policy.h"
  45 #include "chrome/browser/extensions/extension_sync_data.h"
  46 #include "chrome/browser/extensions/extension_sync_service.h"
  47 #include "chrome/browser/extensions/extension_util.h"
  48 #include "chrome/browser/extensions/external_install_error.h"
  49 #include "chrome/browser/extensions/external_install_manager.h"
  50 #include "chrome/browser/extensions/external_policy_loader.h"
  51 #include "chrome/browser/extensions/external_pref_loader.h"
  52 #include "chrome/browser/extensions/external_provider_impl.h"
  53 #include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
  54 #include "chrome/browser/extensions/installed_loader.h"
  55 #include "chrome/browser/extensions/pack_extension_job.h"
  56 #include "chrome/browser/extensions/pending_extension_info.h"
  57 #include "chrome/browser/extensions/pending_extension_manager.h"
  58 #include "chrome/browser/extensions/test_blacklist.h"
  59 #include "chrome/browser/extensions/test_extension_system.h"
  60 #include "chrome/browser/extensions/unpacked_installer.h"
  61 #include "chrome/browser/extensions/updater/extension_updater.h"
  62 #include "chrome/browser/prefs/pref_service_syncable.h"
  63 #include "chrome/browser/supervised_user/supervised_user_service.h"
  64 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
  65 #include "chrome/browser/sync/profile_sync_service.h"
  66 #include "chrome/browser/sync/profile_sync_service_factory.h"
  67 #include "chrome/common/chrome_constants.h"
  68 #include "chrome/common/chrome_switches.h"
  69 #include "chrome/common/extensions/api/plugins/plugins_handler.h"
  70 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  71 #include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
  72 #include "chrome/common/extensions/manifest_url_handler.h"
  73 #include "chrome/common/pref_names.h"
  74 #include "chrome/common/url_constants.h"
  75 #include "chrome/test/base/scoped_browser_locale.h"
  76 #include "chrome/test/base/testing_pref_service_syncable.h"
  77 #include "chrome/test/base/testing_profile.h"
  78 #include "components/crx_file/id_util.h"
  79 #include "components/pref_registry/pref_registry_syncable.h"
  80 #include "content/public/browser/dom_storage_context.h"
  81 #include "content/public/browser/gpu_data_manager.h"
  82 #include "content/public/browser/indexed_db_context.h"
  83 #include "content/public/browser/notification_registrar.h"
  84 #include "content/public/browser/notification_service.h"
  85 #include "content/public/browser/plugin_service.h"
  86 #include "content/public/browser/render_process_host.h"
  87 #include "content/public/browser/storage_partition.h"
  88 #include "content/public/common/content_constants.h"
  89 #include "content/public/test/test_utils.h"
  90 #include "extensions/browser/extension_registry.h"
  91 #include "extensions/browser/extension_system.h"
  92 #include "extensions/browser/external_provider_interface.h"
  93 #include "extensions/browser/install_flag.h"
  94 #include "extensions/browser/management_policy.h"
  95 #include "extensions/browser/test_management_policy.h"
  96 #include "extensions/browser/uninstall_reason.h"
  97 #include "extensions/common/constants.h"
  98 #include "extensions/common/extension.h"
  99 #include "extensions/common/extension_builder.h"
 100 #include "extensions/common/extension_l10n_util.h"
 101 #include "extensions/common/extension_resource.h"
 102 #include "extensions/common/feature_switch.h"
 103 #include "extensions/common/manifest_constants.h"
 104 #include "extensions/common/manifest_handlers/background_info.h"
 105 #include "extensions/common/permissions/permission_set.h"
 106 #include "extensions/common/permissions/permissions_data.h"
 107 #include "extensions/common/switches.h"
 108 #include "extensions/common/url_pattern.h"
 109 #include "extensions/common/value_builder.h"
 110 #include "gpu/config/gpu_info.h"
 111 #include "grit/browser_resources.h"
 112 #include "net/cookies/canonical_cookie.h"
 113 #include "net/cookies/cookie_monster.h"
 114 #include "net/cookies/cookie_options.h"
 115 #include "net/url_request/url_request_context.h"
 116 #include "net/url_request/url_request_context_getter.h"
 117 #include "storage/browser/database/database_tracker.h"
 118 #include "storage/browser/quota/quota_manager.h"
 119 #include "storage/common/database/database_identifier.h"
 120 #include "sync/api/fake_sync_change_processor.h"
 121 #include "sync/api/string_ordinal.h"
 122 #include "sync/api/sync_data.h"
 123 #include "sync/api/sync_error_factory.h"
 124 #include "sync/api/sync_error_factory_mock.h"
 125 #include "sync/api/syncable_service.h"
 126 #include "sync/protocol/app_specifics.pb.h"
 127 #include "sync/protocol/extension_specifics.pb.h"
 128 #include "sync/protocol/sync.pb.h"
 129 #include "testing/gtest/include/gtest/gtest.h"
 130 #include "testing/platform_test.h"
 131 #include "url/gurl.h"
 132
 133 #if defined(OS_CHROMEOS)
 134 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
 135 #include "chrome/browser/chromeos/settings/cros_settings.h"
 136 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 137 #endif
 138
 139 // The blacklist tests rely on safe browsing.
 140 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 141 #define ENABLE_BLACKLIST_TESTS
 142 #endif
 143
 144 using base::DictionaryValue;
 145 using base::ListValue;
 146 using base::Value;
 147 using content::BrowserContext;
 148 using content::BrowserThread;
 149 using content::DOMStorageContext;
 150 using content::IndexedDBContext;
 151 using content::PluginService;
 152 using extensions::APIPermission;
 153 using extensions::APIPermissionSet;
 154 using extensions::AppSorting;
 155 using extensions::Blacklist;
 156 using extensions::CrxInstaller;
 157 using extensions::Extension;
 158 using extensions::ExtensionCreator;
 159 using extensions::ExtensionPrefs;
 160 using extensions::ExtensionRegistry;
 161 using extensions::ExtensionResource;
 162 using extensions::ExtensionSystem;
 163 using extensions::FakeSafeBrowsingDatabaseManager;
 164 using extensions::FeatureSwitch;
 165 using extensions::Manifest;
 166 using extensions::PermissionSet;
 167 using extensions::TestExtensionSystem;
 168 using extensions::UnloadedExtensionInfo;
 169 using extensions::URLPatternSet;
 170
 171 namespace keys = extensions::manifest_keys;
 172
 173 namespace {
 174
 175 // Extension ids used during testing.
 176 const char good0[] = "behllobkkfkfnphdnhnkndlbkcpglgmj";
 177 const char good1[] = "hpiknbiabeeppbpihjehijgoemciehgk";
 178 const char good2[] = "bjafgdebaacbbbecmhlhpofkepfkgcpa";
 179 const char all_zero[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 180 const char good2048[] = "nmgjhmhbleinmjpbdhgajfjkbijcmgbh";
 181 const char good_crx[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 182 const char hosted_app[] = "kbmnembihfiondgfjekmnmcbddelicoi";
 183 const char page_action[] = "obcimlgaoabeegjmmpldobjndiealpln";
 184 const char theme_crx[] = "iamefpfkojoapidjnbafmgkgncegbkad";
 185 const char theme2_crx[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 186 const char permissions_crx[] = "eagpmdpfmaekmmcejjbmjoecnejeiiin";
 187 const char unpacked[] = "cbcdidchbppangcjoddlpdjlenngjldk";
 188 const char updates_from_webstore[] = "akjooamlhcgeopfifcmlggaebeocgokj";
 189
 190 struct ExtensionsOrder {
 191   bool operator()(const scoped_refptr<const Extension>& a,
 192                   const scoped_refptr<const Extension>& b) {
 193     return a->name() < b->name();
 194   }
 195 };
 196
 197 static std::vector<base::string16> GetErrors() {
 198   const std::vector<base::string16>* errors =
 199       ExtensionErrorReporter::GetInstance()->GetErrors();
 200   std::vector<base::string16> ret_val;
 201
 202   for (std::vector<base::string16>::const_iterator iter = errors->begin();
 203        iter != errors->end(); ++iter) {
 204     std::string utf8_error = base::UTF16ToUTF8(*iter);
 205     if (utf8_error.find(".svn") == std::string::npos) {
 206       ret_val.push_back(*iter);
 207     }
 208   }
 209
 210   // The tests rely on the errors being in a certain order, which can vary
 211   // depending on how filesystem iteration works.
 212   std::stable_sort(ret_val.begin(), ret_val.end());
 213
 214   return ret_val;
 215 }
 216
 217 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
 218   int schemes = URLPattern::SCHEME_ALL;
 219   extent->AddPattern(URLPattern(schemes, pattern));
 220 }
 221
 222 base::FilePath GetTemporaryFile() {
 223   base::FilePath temp_file;
 224   CHECK(base::CreateTemporaryFile(&temp_file));
 225   return temp_file;
 226 }
 227
 228 bool WaitForCountNotificationsCallback(int *count) {
 229   return --(*count) == 0;
 230 }
 231
 232 }  // namespace
 233
 234 class MockExtensionProvider : public extensions::ExternalProviderInterface {
 235  public:
 236   MockExtensionProvider(
 237       VisitorInterface* visitor,
 238       Manifest::Location location)
 239     : location_(location), visitor_(visitor), visit_count_(0) {
 240   }
 241
 242   virtual ~MockExtensionProvider() {}
 243
 244   void UpdateOrAddExtension(const std::string& id,
 245                             const std::string& version,
 246                             const base::FilePath& path) {
 247     extension_map_[id] = std::make_pair(version, path);
 248   }
 249
 250   void RemoveExtension(const std::string& id) {
 251     extension_map_.erase(id);
 252   }
 253
 254   // ExternalProvider implementation:
 255   virtual void VisitRegisteredExtension() OVERRIDE {
 256     visit_count_++;
 257     for (DataMap::const_iterator i = extension_map_.begin();
 258          i != extension_map_.end(); ++i) {
 259       Version version(i->second.first);
 260
 261       visitor_->OnExternalExtensionFileFound(
 262           i->first, &version, i->second.second, location_,
 263           Extension::NO_FLAGS, false);
 264     }
 265     visitor_->OnExternalProviderReady(this);
 266   }
 267
 268   virtual bool HasExtension(const std::string& id) const OVERRIDE {
 269     return extension_map_.find(id) != extension_map_.end();
 270   }
 271
 272   virtual bool GetExtensionDetails(
 273       const std::string& id,
 274       Manifest::Location* location,
 275       scoped_ptr<Version>* version) const OVERRIDE {
 276     DataMap::const_iterator it = extension_map_.find(id);
 277     if (it == extension_map_.end())
 278       return false;
 279
 280     if (version)
 281       version->reset(new Version(it->second.first));
 282
 283     if (location)
 284       *location = location_;
 285
 286     return true;
 287   }
 288
 289   virtual bool IsReady() const OVERRIDE {
 290     return true;
 291   }
 292
 293   virtual void ServiceShutdown() OVERRIDE {
 294   }
 295
 296   int visit_count() const { return visit_count_; }
 297   void set_visit_count(int visit_count) {
 298     visit_count_ = visit_count;
 299   }
 300
 301  private:
 302   typedef std::map< std::string, std::pair<std::string, base::FilePath> >
 303       DataMap;
 304   DataMap extension_map_;
 305   Manifest::Location location_;
 306   VisitorInterface* visitor_;
 307
 308   // visit_count_ tracks the number of calls to VisitRegisteredExtension().
 309   // Mutable because it must be incremented on each call to
 310   // VisitRegisteredExtension(), which must be a const method to inherit
 311   // from the class being mocked.
 312   mutable int visit_count_;
 313
 314   DISALLOW_COPY_AND_ASSIGN(MockExtensionProvider);
 315 };
 316
 317 class MockProviderVisitor
 318     : public extensions::ExternalProviderInterface::VisitorInterface {
 319  public:
 320   // The provider will return |fake_base_path| from
 321   // GetBaseCrxFilePath().  User can test the behavior with
 322   // and without an empty path using this parameter.
 323   explicit MockProviderVisitor(base::FilePath fake_base_path)
 324       : ids_found_(0),
 325         fake_base_path_(fake_base_path),
 326         expected_creation_flags_(Extension::NO_FLAGS) {
 327     profile_.reset(new TestingProfile);
 328   }
 329
 330   MockProviderVisitor(base::FilePath fake_base_path,
 331                       int expected_creation_flags)
 332       : ids_found_(0),
 333         fake_base_path_(fake_base_path),
 334         expected_creation_flags_(expected_creation_flags) {
 335   }
 336
 337   int Visit(const std::string& json_data) {
 338     // Give the test json file to the provider for parsing.
 339     provider_.reset(new extensions::ExternalProviderImpl(
 340         this,
 341         new extensions::ExternalTestingLoader(json_data, fake_base_path_),
 342         profile_.get(),
 343         Manifest::EXTERNAL_PREF,
 344         Manifest::EXTERNAL_PREF_DOWNLOAD,
 345         Extension::NO_FLAGS));
 346
 347     // We also parse the file into a dictionary to compare what we get back
 348     // from the provider.
 349     JSONStringValueSerializer serializer(json_data);
 350     base::Value* json_value = serializer.Deserialize(NULL, NULL);
 351
 352     if (!json_value || !json_value->IsType(base::Value::TYPE_DICTIONARY)) {
 353       NOTREACHED() << "Unable to deserialize json data";
 354       return -1;
 355     } else {
 356       base::DictionaryValue* external_extensions =
 357           static_cast<base::DictionaryValue*>(json_value);
 358       prefs_.reset(external_extensions);
 359     }
 360
 361     // Reset our counter.
 362     ids_found_ = 0;
 363     // Ask the provider to look up all extensions and return them.
 364     provider_->VisitRegisteredExtension();
 365
 366     return ids_found_;
 367   }
 368
 369   virtual bool OnExternalExtensionFileFound(const std::string& id,
 370                                             const Version* version,
 371                                             const base::FilePath& path,
 372                                             Manifest::Location unused,
 373                                             int creation_flags,
 374                                             bool mark_acknowledged) OVERRIDE {
 375     EXPECT_EQ(expected_creation_flags_, creation_flags);
 376
 377     ++ids_found_;
 378     base::DictionaryValue* pref;
 379     // This tests is to make sure that the provider only notifies us of the
 380     // values we gave it. So if the id we doesn't exist in our internal
 381     // dictionary then something is wrong.
 382     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
 383        << "Got back ID (" << id.c_str() << ") we weren't expecting";
 384
 385     EXPECT_TRUE(path.IsAbsolute());
 386     if (!fake_base_path_.empty())
 387       EXPECT_TRUE(fake_base_path_.IsParent(path));
 388
 389     if (pref) {
 390       EXPECT_TRUE(provider_->HasExtension(id));
 391
 392       // Ask provider if the extension we got back is registered.
 393       Manifest::Location location = Manifest::INVALID_LOCATION;
 394       scoped_ptr<Version> v1;
 395       base::FilePath crx_path;
 396
 397       EXPECT_TRUE(provider_->GetExtensionDetails(id, NULL, &v1));
 398       EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
 399
 400       scoped_ptr<Version> v2;
 401       EXPECT_TRUE(provider_->GetExtensionDetails(id, &location, &v2));
 402       EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
 403       EXPECT_STREQ(version->GetString().c_str(), v2->GetString().c_str());
 404       EXPECT_EQ(Manifest::EXTERNAL_PREF, location);
 405
 406       // Remove it so we won't count it ever again.
 407       prefs_->Remove(id, NULL);
 408     }
 409     return true;
 410   }
 411
 412   virtual bool OnExternalExtensionUpdateUrlFound(
 413       const std::string& id,
 414       const std::string& install_parameter,
 415       const GURL& update_url,
 416       Manifest::Location location,
 417       int creation_flags,
 418       bool mark_acknowledged) OVERRIDE {
 419     ++ids_found_;
 420     base::DictionaryValue* pref;
 421     // This tests is to make sure that the provider only notifies us of the
 422     // values we gave it. So if the id we doesn't exist in our internal
 423     // dictionary then something is wrong.
 424     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
 425        << L"Got back ID (" << id.c_str() << ") we weren't expecting";
 426     EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
 427
 428     if (pref) {
 429       EXPECT_TRUE(provider_->HasExtension(id));
 430
 431       // External extensions with update URLs do not have versions.
 432       scoped_ptr<Version> v1;
 433       Manifest::Location location1 = Manifest::INVALID_LOCATION;
 434       EXPECT_TRUE(provider_->GetExtensionDetails(id, &location1, &v1));
 435       EXPECT_FALSE(v1.get());
 436       EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
 437
 438       std::string parsed_install_parameter;
 439       pref->GetString("install_parameter", &parsed_install_parameter);
 440       EXPECT_EQ(parsed_install_parameter, install_parameter);
 441
 442       // Remove it so we won't count it again.
 443       prefs_->Remove(id, NULL);
 444     }
 445     return true;
 446   }
 447
 448   virtual void OnExternalProviderReady(
 449       const extensions::ExternalProviderInterface* provider) OVERRIDE {
 450     EXPECT_EQ(provider, provider_.get());
 451     EXPECT_TRUE(provider->IsReady());
 452   }
 453
 454  private:
 455   int ids_found_;
 456   base::FilePath fake_base_path_;
 457   int expected_creation_flags_;
 458   scoped_ptr<extensions::ExternalProviderImpl> provider_;
 459   scoped_ptr<base::DictionaryValue> prefs_;
 460   scoped_ptr<TestingProfile> profile_;
 461
 462   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 463 };
 464
 465 class ExtensionServiceTest : public extensions::ExtensionServiceTestBase,
 466                              public content::NotificationObserver {
 467  public:
 468   ExtensionServiceTest()
 469       : unloaded_reason_(UnloadedExtensionInfo::REASON_UNDEFINED),
 470         installed_(NULL),
 471         was_update_(false),
 472         override_external_install_prompt_(
 473             FeatureSwitch::prompt_for_external_extensions(),
 474             false),
 475         expected_extensions_count_(0) {
 476     registrar_.Add(this,
 477                    extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
 478                    content::NotificationService::AllSources());
 479     registrar_.Add(this,
 480                    extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 481                    content::NotificationService::AllSources());
 482     registrar_.Add(
 483         this,
 484         extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
 485         content::NotificationService::AllSources());
 486   }
 487
 488   virtual void Observe(int type,
 489                        const content::NotificationSource& source,
 490                        const content::NotificationDetails& details) OVERRIDE {
 491     switch (type) {
 492       case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
 493         const Extension* extension =
 494             content::Details<const Extension>(details).ptr();
 495         loaded_.push_back(make_scoped_refptr(extension));
 496         // The tests rely on the errors being in a certain order, which can vary
 497         // depending on how filesystem iteration works.
 498         std::stable_sort(loaded_.begin(), loaded_.end(), ExtensionsOrder());
 499         break;
 500       }
 501
 502       case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
 503         UnloadedExtensionInfo* unloaded_info =
 504             content::Details<UnloadedExtensionInfo>(details).ptr();
 505         const Extension* e = unloaded_info->extension;
 506         unloaded_id_ = e->id();
 507         unloaded_reason_ = unloaded_info->reason;
 508         extensions::ExtensionList::iterator i =
 509             std::find(loaded_.begin(), loaded_.end(), e);
 510         // TODO(erikkay) fix so this can be an assert.  Right now the tests
 511         // are manually calling clear() on loaded_, so this isn't doable.
 512         if (i == loaded_.end())
 513           return;
 514         loaded_.erase(i);
 515         break;
 516       }
 517       case extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
 518         const extensions::InstalledExtensionInfo* installed_info =
 519             content::Details<const extensions::InstalledExtensionInfo>(details)
 520                 .ptr();
 521         installed_ = installed_info->extension;
 522         was_update_ = installed_info->is_update;
 523         old_name_ = installed_info->old_name;
 524         break;
 525       }
 526
 527       default:
 528         DCHECK(false);
 529     }
 530   }
 531
 532   void AddMockExternalProvider(
 533       extensions::ExternalProviderInterface* provider) {
 534     service()->AddProviderForTesting(provider);
 535   }
 536
 537   void MockSyncStartFlare(bool* was_called,
 538                           syncer::ModelType* model_type_passed_in,
 539                           syncer::ModelType model_type) {
 540     *was_called = true;
 541     *model_type_passed_in = model_type;
 542   }
 543
 544  protected:
 545   // Paths to some of the fake extensions.
 546   base::FilePath good0_path() {
 547     return data_dir()
 548         .AppendASCII("good")
 549         .AppendASCII("Extensions")
 550         .AppendASCII(good0)
 551         .AppendASCII("1.0.0.0");
 552   }
 553
 554   base::FilePath good1_path() {
 555     return data_dir()
 556         .AppendASCII("good")
 557         .AppendASCII("Extensions")
 558         .AppendASCII(good1)
 559         .AppendASCII("2");
 560   }
 561
 562   base::FilePath good2_path() {
 563     return data_dir()
 564         .AppendASCII("good")
 565         .AppendASCII("Extensions")
 566         .AppendASCII(good2)
 567         .AppendASCII("1.0");
 568   }
 569
 570   void TestExternalProvider(MockExtensionProvider* provider,
 571                             Manifest::Location location);
 572
 573   void PackCRX(const base::FilePath& dir_path,
 574                const base::FilePath& pem_path,
 575                const base::FilePath& crx_path) {
 576     // Use the existing pem key, if provided.
 577     base::FilePath pem_output_path;
 578     if (pem_path.value().empty()) {
 579       pem_output_path = crx_path.DirName().AppendASCII("temp.pem");
 580     } else {
 581       ASSERT_TRUE(base::PathExists(pem_path));
 582     }
 583
 584     ASSERT_TRUE(base::DeleteFile(crx_path, false));
 585
 586     scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
 587     ASSERT_TRUE(creator->Run(dir_path,
 588                              crx_path,
 589                              pem_path,
 590                              pem_output_path,
 591                              ExtensionCreator::kOverwriteCRX));
 592
 593     ASSERT_TRUE(base::PathExists(crx_path));
 594   }
 595
 596   enum InstallState {
 597     INSTALL_FAILED,
 598     INSTALL_UPDATED,
 599     INSTALL_NEW,
 600     INSTALL_WITHOUT_LOAD,
 601   };
 602
 603   const Extension* PackAndInstallCRX(const base::FilePath& dir_path,
 604                                      const base::FilePath& pem_path,
 605                                      InstallState install_state,
 606                                      int creation_flags) {
 607     base::FilePath crx_path;
 608     base::ScopedTempDir temp_dir;
 609     EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
 610     crx_path = temp_dir.path().AppendASCII("temp.crx");
 611
 612     PackCRX(dir_path, pem_path, crx_path);
 613     return InstallCRX(crx_path, install_state, creation_flags);
 614   }
 615
 616   const Extension* PackAndInstallCRX(const base::FilePath& dir_path,
 617                                      const base::FilePath& pem_path,
 618                                      InstallState install_state) {
 619     return PackAndInstallCRX(dir_path, pem_path, install_state,
 620                              Extension::NO_FLAGS);
 621   }
 622
 623   const Extension* PackAndInstallCRX(const base::FilePath& dir_path,
 624                                      InstallState install_state) {
 625     return PackAndInstallCRX(dir_path, base::FilePath(), install_state,
 626                              Extension::NO_FLAGS);
 627   }
 628
 629   // Attempts to install an extension. Use INSTALL_FAILED if the installation
 630   // is expected to fail.
 631   // If |install_state| is INSTALL_UPDATED, and |expected_old_name| is
 632   // non-empty, expects that the existing extension's title was
 633   // |expected_old_name|.
 634   const Extension* InstallCRX(const base::FilePath& path,
 635                               InstallState install_state,
 636                               int creation_flags,
 637                               const std::string& expected_old_name) {
 638     InstallCRXInternal(path, creation_flags);
 639     return VerifyCrxInstall(path, install_state, expected_old_name);
 640   }
 641
 642   // Attempts to install an extension. Use INSTALL_FAILED if the installation
 643   // is expected to fail.
 644   const Extension* InstallCRX(const base::FilePath& path,
 645                               InstallState install_state,
 646                               int creation_flags) {
 647     return InstallCRX(path, install_state, creation_flags, std::string());
 648   }
 649
 650   // Attempts to install an extension. Use INSTALL_FAILED if the installation
 651   // is expected to fail.
 652   const Extension* InstallCRX(const base::FilePath& path,
 653                               InstallState install_state) {
 654     return InstallCRX(path, install_state, Extension::NO_FLAGS);
 655   }
 656
 657   const Extension* InstallCRXFromWebStore(const base::FilePath& path,
 658                                           InstallState install_state) {
 659     InstallCRXInternal(path, Extension::FROM_WEBSTORE);
 660     return VerifyCrxInstall(path, install_state);
 661   }
 662
 663   const Extension* InstallCRXWithLocation(const base::FilePath& crx_path,
 664                                           Manifest::Location install_location,
 665                                           InstallState install_state) {
 666     EXPECT_TRUE(base::PathExists(crx_path))
 667         << "Path does not exist: "<< crx_path.value().c_str();
 668     // no client (silent install)
 669     scoped_refptr<CrxInstaller> installer(
 670         CrxInstaller::CreateSilent(service()));
 671     installer->set_install_source(install_location);
 672
 673     content::WindowedNotificationObserver observer(
 674         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
 675         content::NotificationService::AllSources());
 676     installer->InstallCrx(crx_path);
 677     observer.Wait();
 678
 679     return VerifyCrxInstall(crx_path, install_state);
 680   }
 681
 682   // Verifies the result of a CRX installation. Used by InstallCRX. Set the
 683   // |install_state| to INSTALL_FAILED if the installation is expected to fail.
 684   // Returns an Extension pointer if the install succeeded, NULL otherwise.
 685   const Extension* VerifyCrxInstall(const base::FilePath& path,
 686                                     InstallState install_state) {
 687     return VerifyCrxInstall(path, install_state, std::string());
 688   }
 689
 690   // Verifies the result of a CRX installation. Used by InstallCRX. Set the
 691   // |install_state| to INSTALL_FAILED if the installation is expected to fail.
 692   // If |install_state| is INSTALL_UPDATED, and |expected_old_name| is
 693   // non-empty, expects that the existing extension's title was
 694   // |expected_old_name|.
 695   // Returns an Extension pointer if the install succeeded, NULL otherwise.
 696   const Extension* VerifyCrxInstall(const base::FilePath& path,
 697                                     InstallState install_state,
 698                                     const std::string& expected_old_name) {
 699     std::vector<base::string16> errors = GetErrors();
 700     const Extension* extension = NULL;
 701     if (install_state != INSTALL_FAILED) {
 702       if (install_state == INSTALL_NEW)
 703         ++expected_extensions_count_;
 704
 705       EXPECT_TRUE(installed_) << path.value();
 706       // If and only if INSTALL_UPDATED, it should have the is_update flag.
 707       EXPECT_EQ(install_state == INSTALL_UPDATED, was_update_)
 708           << path.value();
 709       // If INSTALL_UPDATED, old_name_ should match the given string.
 710       if (install_state == INSTALL_UPDATED && !expected_old_name.empty())
 711         EXPECT_EQ(expected_old_name, old_name_);
 712       EXPECT_EQ(0u, errors.size()) << path.value();
 713
 714       if (install_state == INSTALL_WITHOUT_LOAD) {
 715         EXPECT_EQ(0u, loaded_.size()) << path.value();
 716       } else {
 717         EXPECT_EQ(1u, loaded_.size()) << path.value();
 718         size_t actual_extension_count =
 719             registry()->enabled_extensions().size() +
 720             registry()->disabled_extensions().size();
 721         EXPECT_EQ(expected_extensions_count_, actual_extension_count) <<
 722             path.value();
 723         extension = loaded_[0].get();
 724         EXPECT_TRUE(service()->GetExtensionById(extension->id(), false))
 725             << path.value();
 726       }
 727
 728       for (std::vector<base::string16>::iterator err = errors.begin();
 729         err != errors.end(); ++err) {
 730         LOG(ERROR) << *err;
 731       }
 732     } else {
 733       EXPECT_FALSE(installed_) << path.value();
 734       EXPECT_EQ(0u, loaded_.size()) << path.value();
 735       EXPECT_EQ(1u, errors.size()) << path.value();
 736     }
 737
 738     installed_ = NULL;
 739     was_update_ = false;
 740     old_name_ = "";
 741     loaded_.clear();
 742     ExtensionErrorReporter::GetInstance()->ClearErrors();
 743     return extension;
 744   }
 745
 746   enum UpdateState {
 747     FAILED_SILENTLY,
 748     FAILED,
 749     UPDATED,
 750     INSTALLED,
 751     DISABLED,
 752     ENABLED
 753   };
 754
 755   void BlackListWebGL() {
 756     static const std::string json_blacklist =
 757       "{\n"
 758       "  \"name\": \"gpu blacklist\",\n"
 759       "  \"version\": \"1.0\",\n"
 760       "  \"entries\": [\n"
 761       "    {\n"
 762       "      \"id\": 1,\n"
 763       "      \"features\": [\"webgl\"]\n"
 764       "    }\n"
 765       "  ]\n"
 766       "}";
 767     gpu::GPUInfo gpu_info;
 768     content::GpuDataManager::GetInstance()->InitializeForTesting(
 769         json_blacklist, gpu_info);
 770   }
 771
 772   // Helper method to set up a WindowedNotificationObserver to wait for a
 773   // specific CrxInstaller to finish if we don't know the value of the
 774   // |installer| yet.
 775   static bool IsCrxInstallerDone(extensions::CrxInstaller** installer,
 776                                  const content::NotificationSource& source,
 777                                  const content::NotificationDetails& details) {
 778     return content::Source<extensions::CrxInstaller>(source).ptr() ==
 779            *installer;
 780   }
 781
 782   void PackCRXAndUpdateExtension(const std::string& id,
 783                                  const base::FilePath& dir_path,
 784                                  const base::FilePath& pem_path,
 785                                  UpdateState expected_state) {
 786     base::ScopedTempDir temp_dir;
 787     EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
 788     base::FilePath crx_path = temp_dir.path().AppendASCII("temp.crx");
 789
 790     PackCRX(dir_path, pem_path, crx_path);
 791     UpdateExtension(id, crx_path, expected_state);
 792   }
 793
 794   void UpdateExtension(const std::string& id,
 795                        const base::FilePath& in_path,
 796                        UpdateState expected_state) {
 797     ASSERT_TRUE(base::PathExists(in_path));
 798
 799     // We need to copy this to a temporary location because Update() will delete
 800     // it.
 801     base::FilePath path = temp_dir().path();
 802     path = path.Append(in_path.BaseName());
 803     ASSERT_TRUE(base::CopyFile(in_path, path));
 804
 805     int previous_enabled_extension_count =
 806         registry()->enabled_extensions().size();
 807     int previous_installed_extension_count =
 808         previous_enabled_extension_count +
 809         registry()->disabled_extensions().size();
 810
 811     extensions::CrxInstaller* installer = NULL;
 812     content::WindowedNotificationObserver observer(
 813         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
 814         base::Bind(&IsCrxInstallerDone, &installer));
 815     service()->UpdateExtension(id, path, true, &installer);
 816
 817     if (installer)
 818       observer.Wait();
 819     else
 820       base::RunLoop().RunUntilIdle();
 821
 822     std::vector<base::string16> errors = GetErrors();
 823     int error_count = errors.size();
 824     int enabled_extension_count = registry()->enabled_extensions().size();
 825     int installed_extension_count =
 826         enabled_extension_count + registry()->disabled_extensions().size();
 827
 828     int expected_error_count = (expected_state == FAILED) ? 1 : 0;
 829     EXPECT_EQ(expected_error_count, error_count) << path.value();
 830
 831     if (expected_state <= FAILED) {
 832       EXPECT_EQ(previous_enabled_extension_count,
 833                 enabled_extension_count);
 834       EXPECT_EQ(previous_installed_extension_count,
 835                 installed_extension_count);
 836     } else {
 837       int expected_installed_extension_count =
 838           (expected_state >= INSTALLED) ? 1 : 0;
 839       int expected_enabled_extension_count =
 840           (expected_state >= ENABLED) ? 1 : 0;
 841       EXPECT_EQ(expected_installed_extension_count,
 842                 installed_extension_count);
 843       EXPECT_EQ(expected_enabled_extension_count,
 844                 enabled_extension_count);
 845     }
 846
 847     // Update() should the temporary input file.
 848     EXPECT_FALSE(base::PathExists(path));
 849   }
 850
 851   void TerminateExtension(const std::string& id) {
 852     const Extension* extension = service()->GetInstalledExtension(id);
 853     if (!extension) {
 854       ADD_FAILURE();
 855       return;
 856     }
 857     service()->TrackTerminatedExtensionForTest(extension);
 858   }
 859
 860   size_t GetPrefKeyCount() {
 861     const base::DictionaryValue* dict =
 862         profile()->GetPrefs()->GetDictionary("extensions.settings");
 863     if (!dict) {
 864       ADD_FAILURE();
 865       return 0;
 866     }
 867     return dict->size();
 868   }
 869
 870   void UninstallExtension(const std::string& id, bool use_helper) {
 871     // Verify that the extension is installed.
 872     base::FilePath extension_path = extensions_install_dir().AppendASCII(id);
 873     EXPECT_TRUE(base::PathExists(extension_path));
 874     size_t pref_key_count = GetPrefKeyCount();
 875     EXPECT_GT(pref_key_count, 0u);
 876     ValidateIntegerPref(id, "state", Extension::ENABLED);
 877
 878     // Uninstall it.
 879     if (use_helper) {
 880       EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(
 881           service(), id, extensions::UNINSTALL_REASON_FOR_TESTING));
 882     } else {
 883       EXPECT_TRUE(service()->UninstallExtension(
 884           id,
 885           extensions::UNINSTALL_REASON_FOR_TESTING,
 886           base::Bind(&base::DoNothing),
 887           NULL));
 888     }
 889     --expected_extensions_count_;
 890
 891     // We should get an unload notification.
 892     EXPECT_FALSE(unloaded_id_.empty());
 893     EXPECT_EQ(id, unloaded_id_);
 894
 895     // Verify uninstalled state.
 896     size_t new_pref_key_count = GetPrefKeyCount();
 897     if (new_pref_key_count == pref_key_count) {
 898       ValidateIntegerPref(id, "state",
 899                           Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 900     } else {
 901       EXPECT_EQ(new_pref_key_count, pref_key_count - 1);
 902     }
 903
 904     // The extension should not be in the service anymore.
 905     EXPECT_FALSE(service()->GetInstalledExtension(id));
 906     base::RunLoop().RunUntilIdle();
 907
 908     // The directory should be gone.
 909     EXPECT_FALSE(base::PathExists(extension_path));
 910   }
 911
 912   void ValidatePrefKeyCount(size_t count) {
 913     EXPECT_EQ(count, GetPrefKeyCount());
 914   }
 915
 916   testing::AssertionResult ValidateBooleanPref(
 917       const std::string& extension_id,
 918       const std::string& pref_path,
 919       bool expected_val) {
 920     std::string msg = "while checking: ";
 921     msg += extension_id;
 922     msg += " ";
 923     msg += pref_path;
 924     msg += " == ";
 925     msg += expected_val ? "true" : "false";
 926
 927     PrefService* prefs = profile()->GetPrefs();
 928     const base::DictionaryValue* dict =
 929         prefs->GetDictionary("extensions.settings");
 930     if (!dict) {
 931       return testing::AssertionFailure()
 932           << "extension.settings does not exist " << msg;
 933     }
 934
 935     const base::DictionaryValue* pref = NULL;
 936     if (!dict->GetDictionary(extension_id, &pref)) {
 937       return testing::AssertionFailure()
 938           << "extension pref does not exist " << msg;
 939     }
 940
 941     bool val;
 942     if (!pref->GetBoolean(pref_path, &val)) {
 943       return testing::AssertionFailure()
 944           << pref_path << " pref not found " << msg;
 945     }
 946
 947     return expected_val == val
 948         ? testing::AssertionSuccess()
 949         : testing::AssertionFailure() << "base::Value is incorrect " << msg;
 950   }
 951
 952   bool IsPrefExist(const std::string& extension_id,
 953                    const std::string& pref_path) {
 954     const base::DictionaryValue* dict =
 955         profile()->GetPrefs()->GetDictionary("extensions.settings");
 956     if (dict == NULL) return false;
 957     const base::DictionaryValue* pref = NULL;
 958     if (!dict->GetDictionary(extension_id, &pref)) {
 959       return false;
 960     }
 961     if (pref == NULL) {
 962       return false;
 963     }
 964     bool val;
 965     if (!pref->GetBoolean(pref_path, &val)) {
 966       return false;
 967     }
 968     return true;
 969   }
 970
 971   void ValidateIntegerPref(const std::string& extension_id,
 972                            const std::string& pref_path,
 973                            int expected_val) {
 974     std::string msg = " while checking: ";
 975     msg += extension_id;
 976     msg += " ";
 977     msg += pref_path;
 978     msg += " == ";
 979     msg += base::IntToString(expected_val);
 980
 981     PrefService* prefs = profile()->GetPrefs();
 982     const base::DictionaryValue* dict =
 983         prefs->GetDictionary("extensions.settings");
 984     ASSERT_TRUE(dict != NULL) << msg;
 985     const base::DictionaryValue* pref = NULL;
 986     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
 987     EXPECT_TRUE(pref != NULL) << msg;
 988     int val;
 989     ASSERT_TRUE(pref->GetInteger(pref_path, &val)) << msg;
 990     EXPECT_EQ(expected_val, val) << msg;
 991   }
 992
 993   void ValidateStringPref(const std::string& extension_id,
 994                           const std::string& pref_path,
 995                           const std::string& expected_val) {
 996     std::string msg = " while checking: ";
 997     msg += extension_id;
 998     msg += ".manifest.";
 999     msg += pref_path;
1000     msg += " == ";
1001     msg += expected_val;
1002
1003     const base::DictionaryValue* dict =
1004         profile()->GetPrefs()->GetDictionary("extensions.settings");
1005     ASSERT_TRUE(dict != NULL) << msg;
1006     const base::DictionaryValue* pref = NULL;
1007     std::string manifest_path = extension_id + ".manifest";
1008     ASSERT_TRUE(dict->GetDictionary(manifest_path, &pref)) << msg;
1009     EXPECT_TRUE(pref != NULL) << msg;
1010     std::string val;
1011     ASSERT_TRUE(pref->GetString(pref_path, &val)) << msg;
1012     EXPECT_EQ(expected_val, val) << msg;
1013   }
1014
1015   void SetPref(const std::string& extension_id,
1016                const std::string& pref_path,
1017                base::Value* value,
1018                const std::string& msg) {
1019     DictionaryPrefUpdate update(profile()->GetPrefs(), "extensions.settings");
1020     base::DictionaryValue* dict = update.Get();
1021     ASSERT_TRUE(dict != NULL) << msg;
1022     base::DictionaryValue* pref = NULL;
1023     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
1024     EXPECT_TRUE(pref != NULL) << msg;
1025     pref->Set(pref_path, value);
1026   }
1027
1028   void SetPrefInteg(const std::string& extension_id,
1029                     const std::string& pref_path,
1030                     int value) {
1031     std::string msg = " while setting: ";
1032     msg += extension_id;
1033     msg += " ";
1034     msg += pref_path;
1035     msg += " = ";
1036     msg += base::IntToString(value);
1037
1038     SetPref(extension_id, pref_path, new base::FundamentalValue(value), msg);
1039   }
1040
1041   void SetPrefBool(const std::string& extension_id,
1042                    const std::string& pref_path,
1043                    bool value) {
1044     std::string msg = " while setting: ";
1045     msg += extension_id + " " + pref_path;
1046     msg += " = ";
1047     msg += (value ? "true" : "false");
1048
1049     SetPref(extension_id, pref_path, new base::FundamentalValue(value), msg);
1050   }
1051
1052   void ClearPref(const std::string& extension_id,
1053                  const std::string& pref_path) {
1054     std::string msg = " while clearing: ";
1055     msg += extension_id + " " + pref_path;
1056
1057     DictionaryPrefUpdate update(profile()->GetPrefs(), "extensions.settings");
1058     base::DictionaryValue* dict = update.Get();
1059     ASSERT_TRUE(dict != NULL) << msg;
1060     base::DictionaryValue* pref = NULL;
1061     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
1062     EXPECT_TRUE(pref != NULL) << msg;
1063     pref->Remove(pref_path, NULL);
1064   }
1065
1066   void SetPrefStringSet(const std::string& extension_id,
1067                         const std::string& pref_path,
1068                         const std::set<std::string>& value) {
1069     std::string msg = " while setting: ";
1070     msg += extension_id + " " + pref_path;
1071
1072     base::ListValue* list_value = new base::ListValue();
1073     for (std::set<std::string>::const_iterator iter = value.begin();
1074          iter != value.end(); ++iter)
1075       list_value->Append(new base::StringValue(*iter));
1076
1077     SetPref(extension_id, pref_path, list_value, msg);
1078   }
1079
1080   void InitPluginService() {
1081 #if defined(ENABLE_PLUGINS)
1082     PluginService::GetInstance()->Init();
1083 #endif
1084   }
1085
1086   void InitializeExtensionSyncService() {
1087     extension_sync_service_.reset(new ExtensionSyncService(
1088         profile(), ExtensionPrefs::Get(browser_context()), service()));
1089   }
1090
1091   void InitializeEmptyExtensionServiceWithTestingPrefs() {
1092     ExtensionServiceTestBase::ExtensionServiceInitParams params =
1093         CreateDefaultInitParams();
1094     params.pref_file = base::FilePath();
1095     InitializeExtensionService(params);
1096   }
1097
1098   extensions::ManagementPolicy* GetManagementPolicy() {
1099     return ExtensionSystem::Get(browser_context())->management_policy();
1100   }
1101
1102   ExtensionSyncService* extension_sync_service() {
1103     return extension_sync_service_.get();
1104   }
1105
1106  protected:
1107   typedef extensions::ExtensionManagementPrefUpdater<TestingPrefServiceSyncable>
1108       ManagementPrefUpdater;
1109   scoped_ptr<ExtensionSyncService> extension_sync_service_;
1110   extensions::ExtensionList loaded_;
1111   std::string unloaded_id_;
1112   UnloadedExtensionInfo::Reason unloaded_reason_;
1113   const Extension* installed_;
1114   bool was_update_;
1115   std::string old_name_;
1116   FeatureSwitch::ScopedOverride override_external_install_prompt_;
1117
1118  private:
1119   // Create a CrxInstaller and install the CRX file.
1120   // Instead of calling this method yourself, use InstallCRX(), which does extra
1121   // error checking.
1122   void InstallCRXInternal(const base::FilePath& crx_path) {
1123     InstallCRXInternal(crx_path, Extension::NO_FLAGS);
1124   }
1125
1126   void InstallCRXInternal(const base::FilePath& crx_path, int creation_flags) {
1127     ASSERT_TRUE(base::PathExists(crx_path))
1128         << "Path does not exist: "<< crx_path.value().c_str();
1129     scoped_refptr<CrxInstaller> installer(
1130         CrxInstaller::CreateSilent(service()));
1131     installer->set_creation_flags(creation_flags);
1132     if (!(creation_flags & Extension::WAS_INSTALLED_BY_DEFAULT))
1133       installer->set_allow_silent_install(true);
1134
1135     content::WindowedNotificationObserver observer(
1136         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1137         content::Source<extensions::CrxInstaller>(installer.get()));
1138
1139     installer->InstallCrx(crx_path);
1140
1141     observer.Wait();
1142   }
1143
1144   size_t expected_extensions_count_;
1145   content::NotificationRegistrar registrar_;
1146 };
1147
1148 // Receives notifications from a PackExtensionJob, indicating either that
1149 // packing succeeded or that there was some error.
1150 class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
1151  public:
1152   PackExtensionTestClient(const base::FilePath& expected_crx_path,
1153                           const base::FilePath& expected_private_key_path);
1154   virtual void OnPackSuccess(const base::FilePath& crx_path,
1155                              const base::FilePath& private_key_path) OVERRIDE;
1156   virtual void OnPackFailure(const std::string& error_message,
1157                              ExtensionCreator::ErrorType type) OVERRIDE;
1158
1159  private:
1160   const base::FilePath expected_crx_path_;
1161   const base::FilePath expected_private_key_path_;
1162   DISALLOW_COPY_AND_ASSIGN(PackExtensionTestClient);
1163 };
1164
1165 PackExtensionTestClient::PackExtensionTestClient(
1166     const base::FilePath& expected_crx_path,
1167     const base::FilePath& expected_private_key_path)
1168     : expected_crx_path_(expected_crx_path),
1169       expected_private_key_path_(expected_private_key_path) {}
1170
1171 // If packing succeeded, we make sure that the package names match our
1172 // expectations.
1173 void PackExtensionTestClient::OnPackSuccess(
1174     const base::FilePath& crx_path,
1175     const base::FilePath& private_key_path) {
1176   // We got the notification and processed it; we don't expect any further tasks
1177   // to be posted to the current thread, so we should stop blocking and continue
1178   // on with the rest of the test.
1179   // This call to |Quit()| matches the call to |Run()| in the
1180   // |PackPunctuatedExtension| test.
1181   base::MessageLoop::current()->Quit();
1182   EXPECT_EQ(expected_crx_path_.value(), crx_path.value());
1183   EXPECT_EQ(expected_private_key_path_.value(), private_key_path.value());
1184   ASSERT_TRUE(base::PathExists(private_key_path));
1185 }
1186
1187 // The tests are designed so that we never expect to see a packing error.
1188 void PackExtensionTestClient::OnPackFailure(const std::string& error_message,
1189                                             ExtensionCreator::ErrorType type) {
1190   if (type == ExtensionCreator::kCRXExists)
1191      FAIL() << "Packing should not fail.";
1192   else
1193      FAIL() << "Existing CRX should have been overwritten.";
1194 }
1195
1196 // Test loading good extensions from the profile directory.
1197 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
1198   InitPluginService();
1199   InitializeGoodInstalledExtensionService();
1200   service()->Init();
1201
1202   uint32 expected_num_extensions = 3u;
1203   ASSERT_EQ(expected_num_extensions, loaded_.size());
1204
1205   EXPECT_EQ(std::string(good0), loaded_[0]->id());
1206   EXPECT_EQ(std::string("My extension 1"),
1207             loaded_[0]->name());
1208   EXPECT_EQ(std::string("The first extension that I made."),
1209             loaded_[0]->description());
1210   EXPECT_EQ(Manifest::INTERNAL, loaded_[0]->location());
1211   EXPECT_TRUE(service()->GetExtensionById(loaded_[0]->id(), false));
1212   EXPECT_EQ(expected_num_extensions, registry()->enabled_extensions().size());
1213
1214   ValidatePrefKeyCount(3);
1215   ValidateIntegerPref(good0, "state", Extension::ENABLED);
1216   ValidateIntegerPref(good0, "location", Manifest::INTERNAL);
1217   ValidateIntegerPref(good1, "state", Extension::ENABLED);
1218   ValidateIntegerPref(good1, "location", Manifest::INTERNAL);
1219   ValidateIntegerPref(good2, "state", Extension::ENABLED);
1220   ValidateIntegerPref(good2, "location", Manifest::INTERNAL);
1221
1222   URLPatternSet expected_patterns;
1223   AddPattern(&expected_patterns, "file:///*");
1224   AddPattern(&expected_patterns, "http://*.google.com/*");
1225   AddPattern(&expected_patterns, "https://*.google.com/*");
1226   const Extension* extension = loaded_[0].get();
1227   const extensions::UserScriptList& scripts =
1228       extensions::ContentScriptsInfo::GetContentScripts(extension);
1229   ASSERT_EQ(2u, scripts.size());
1230   EXPECT_EQ(expected_patterns, scripts[0].url_patterns());
1231   EXPECT_EQ(2u, scripts[0].js_scripts().size());
1232   ExtensionResource resource00(extension->id(),
1233                                scripts[0].js_scripts()[0].extension_root(),
1234                                scripts[0].js_scripts()[0].relative_path());
1235   base::FilePath expected_path =
1236       base::MakeAbsoluteFilePath(extension->path().AppendASCII("script1.js"));
1237   EXPECT_TRUE(resource00.ComparePathWithDefault(expected_path));
1238   ExtensionResource resource01(extension->id(),
1239                                scripts[0].js_scripts()[1].extension_root(),
1240                                scripts[0].js_scripts()[1].relative_path());
1241   expected_path =
1242       base::MakeAbsoluteFilePath(extension->path().AppendASCII("script2.js"));
1243   EXPECT_TRUE(resource01.ComparePathWithDefault(expected_path));
1244   EXPECT_TRUE(!extensions::PluginInfo::HasPlugins(extension));
1245   EXPECT_EQ(1u, scripts[1].url_patterns().patterns().size());
1246   EXPECT_EQ("http://*.news.com/*",
1247             scripts[1].url_patterns().begin()->GetAsString());
1248   ExtensionResource resource10(extension->id(),
1249                                scripts[1].js_scripts()[0].extension_root(),
1250                                scripts[1].js_scripts()[0].relative_path());
1251   expected_path =
1252       extension->path().AppendASCII("js_files").AppendASCII("script3.js");
1253   expected_path = base::MakeAbsoluteFilePath(expected_path);
1254   EXPECT_TRUE(resource10.ComparePathWithDefault(expected_path));
1255
1256   expected_patterns.ClearPatterns();
1257   AddPattern(&expected_patterns, "http://*.google.com/*");
1258   AddPattern(&expected_patterns, "https://*.google.com/*");
1259   EXPECT_EQ(
1260       expected_patterns,
1261       extension->permissions_data()->active_permissions()->explicit_hosts());
1262
1263   EXPECT_EQ(std::string(good1), loaded_[1]->id());
1264   EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
1265   EXPECT_EQ(std::string(), loaded_[1]->description());
1266   EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
1267             extensions::BackgroundInfo::GetBackgroundURL(loaded_[1].get()));
1268   EXPECT_EQ(0u,
1269             extensions::ContentScriptsInfo::GetContentScripts(loaded_[1].get())
1270                 .size());
1271
1272   // We don't parse the plugins section on Chrome OS.
1273 #if defined(OS_CHROMEOS)
1274   EXPECT_TRUE(!extensions::PluginInfo::HasPlugins(loaded_[1].get()));
1275 #else
1276   ASSERT_TRUE(extensions::PluginInfo::HasPlugins(loaded_[1].get()));
1277   const std::vector<extensions::PluginInfo>* plugins =
1278       extensions::PluginInfo::GetPlugins(loaded_[1].get());
1279   ASSERT_TRUE(plugins);
1280   ASSERT_EQ(2u, plugins->size());
1281   EXPECT_EQ(loaded_[1]->path().AppendASCII("content_plugin.dll").value(),
1282             plugins->at(0).path.value());
1283   EXPECT_TRUE(plugins->at(0).is_public);
1284   EXPECT_EQ(loaded_[1]->path().AppendASCII("extension_plugin.dll").value(),
1285             plugins->at(1).path.value());
1286   EXPECT_FALSE(plugins->at(1).is_public);
1287 #endif
1288
1289   EXPECT_EQ(Manifest::INTERNAL, loaded_[1]->location());
1290
1291   int index = expected_num_extensions - 1;
1292   EXPECT_EQ(std::string(good2), loaded_[index]->id());
1293   EXPECT_EQ(std::string("My extension 3"), loaded_[index]->name());
1294   EXPECT_EQ(std::string(), loaded_[index]->description());
1295   EXPECT_EQ(0u,
1296             extensions::ContentScriptsInfo::GetContentScripts(
1297                 loaded_[index].get()).size());
1298   EXPECT_EQ(Manifest::INTERNAL, loaded_[index]->location());
1299 };
1300
1301 // Test loading bad extensions from the profile directory.
1302 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
1303   // Initialize the test dir with a bad Preferences/extensions.
1304   base::FilePath source_install_dir =
1305       data_dir().AppendASCII("bad").AppendASCII("Extensions");
1306   base::FilePath pref_path =
1307       source_install_dir.DirName().Append(chrome::kPreferencesFilename);
1308
1309   InitializeInstalledExtensionService(pref_path, source_install_dir);
1310
1311   service()->Init();
1312
1313   ASSERT_EQ(4u, GetErrors().size());
1314   ASSERT_EQ(0u, loaded_.size());
1315
1316   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[0]),
1317       std::string("Could not load extension from '*'. ") +
1318       extensions::manifest_errors::kManifestUnreadable)) <<
1319       base::UTF16ToUTF8(GetErrors()[0]);
1320
1321   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[1]),
1322       std::string("Could not load extension from '*'. ") +
1323       extensions::manifest_errors::kManifestUnreadable)) <<
1324       base::UTF16ToUTF8(GetErrors()[1]);
1325
1326   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[2]),
1327       std::string("Could not load extension from '*'. ") +
1328       extensions::manifest_errors::kMissingFile)) <<
1329       base::UTF16ToUTF8(GetErrors()[2]);
1330
1331   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[3]),
1332       std::string("Could not load extension from '*'. ") +
1333       extensions::manifest_errors::kManifestUnreadable)) <<
1334       base::UTF16ToUTF8(GetErrors()[3]);
1335 };
1336
1337 // Test various cases for delayed install because of missing imports.
1338 TEST_F(ExtensionServiceTest, PendingImports) {
1339   InitPluginService();
1340
1341   base::FilePath source_install_dir =
1342       data_dir().AppendASCII("pending_updates_with_imports").AppendASCII(
1343           "Extensions");
1344   base::FilePath pref_path =
1345       source_install_dir.DirName().Append(chrome::kPreferencesFilename);
1346
1347   InitializeInstalledExtensionService(pref_path, source_install_dir);
1348
1349   // Verify there are no pending extensions initially.
1350   EXPECT_FALSE(service()->pending_extension_manager()->HasPendingExtensions());
1351
1352   service()->Init();
1353   // Wait for GarbageCollectExtensions task to complete.
1354   base::RunLoop().RunUntilIdle();
1355
1356   // These extensions are used by the extensions we test below, they must be
1357   // installed.
1358   EXPECT_TRUE(base::PathExists(extensions_install_dir().AppendASCII(
1359       "bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
1360   EXPECT_TRUE(base::PathExists(extensions_install_dir().AppendASCII(
1361       "hpiknbiabeeppbpihjehijgoemciehgk/2")));
1362
1363   // Each of these extensions should have been rejected because of dependencies
1364   // that cannot be satisfied.
1365   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
1366   EXPECT_FALSE(
1367       prefs->GetDelayedInstallInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
1368   EXPECT_FALSE(
1369       prefs->GetInstalledExtensionInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
1370   EXPECT_FALSE(
1371       prefs->GetDelayedInstallInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
1372   EXPECT_FALSE(
1373       prefs->GetInstalledExtensionInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
1374   EXPECT_FALSE(
1375       prefs->GetDelayedInstallInfo("cccccccccccccccccccccccccccccccc"));
1376   EXPECT_FALSE(
1377       prefs->GetInstalledExtensionInfo("cccccccccccccccccccccccccccccccc"));
1378
1379   // Make sure the import started for the extension with a dependency.
1380   EXPECT_TRUE(
1381       prefs->GetDelayedInstallInfo("behllobkkfkfnphdnhnkndlbkcpglgmj"));
1382   EXPECT_EQ(ExtensionPrefs::DELAY_REASON_WAIT_FOR_IMPORTS,
1383       prefs->GetDelayedInstallReason("behllobkkfkfnphdnhnkndlbkcpglgmj"));
1384
1385   EXPECT_FALSE(base::PathExists(extensions_install_dir().AppendASCII(
1386       "behllobkkfkfnphdnhnkndlbkcpglgmj/1.0.0.0")));
1387
1388   EXPECT_TRUE(service()->pending_extension_manager()->HasPendingExtensions());
1389   std::string pending_id("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
1390   EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(pending_id));
1391   // Remove it because we are not testing the pending extension manager's
1392   // ability to download and install extensions.
1393   EXPECT_TRUE(service()->pending_extension_manager()->Remove(pending_id));
1394 }
1395
1396 // Test installing extensions. This test tries to install few extensions using
1397 // crx files. If you need to change those crx files, feel free to repackage
1398 // them, throw away the key used and change the id's above.
1399 TEST_F(ExtensionServiceTest, InstallExtension) {
1400   InitializeEmptyExtensionService();
1401
1402   // Extensions not enabled.
1403   service()->set_extensions_enabled(false);
1404   base::FilePath path = data_dir().AppendASCII("good.crx");
1405   InstallCRX(path, INSTALL_FAILED);
1406   service()->set_extensions_enabled(true);
1407
1408   ValidatePrefKeyCount(0);
1409
1410   // A simple extension that should install without error.
1411   path = data_dir().AppendASCII("good.crx");
1412   InstallCRX(path, INSTALL_NEW);
1413   // TODO(erikkay): verify the contents of the installed extension.
1414
1415   int pref_count = 0;
1416   ValidatePrefKeyCount(++pref_count);
1417   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
1418   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
1419
1420   // An extension with page actions.
1421   path = data_dir().AppendASCII("page_action.crx");
1422   InstallCRX(path, INSTALL_NEW);
1423   ValidatePrefKeyCount(++pref_count);
1424   ValidateIntegerPref(page_action, "state", Extension::ENABLED);
1425   ValidateIntegerPref(page_action, "location", Manifest::INTERNAL);
1426
1427   // Bad signature.
1428   path = data_dir().AppendASCII("bad_signature.crx");
1429   InstallCRX(path, INSTALL_FAILED);
1430   ValidatePrefKeyCount(pref_count);
1431
1432   // 0-length extension file.
1433   path = data_dir().AppendASCII("not_an_extension.crx");
1434   InstallCRX(path, INSTALL_FAILED);
1435   ValidatePrefKeyCount(pref_count);
1436
1437   // Bad magic number.
1438   path = data_dir().AppendASCII("bad_magic.crx");
1439   InstallCRX(path, INSTALL_FAILED);
1440   ValidatePrefKeyCount(pref_count);
1441
1442   // Packed extensions may have folders or files that have underscores.
1443   // This will only cause a warning, rather than a fatal error.
1444   path = data_dir().AppendASCII("bad_underscore.crx");
1445   InstallCRX(path, INSTALL_NEW);
1446   ValidatePrefKeyCount(++pref_count);
1447
1448   // A test for an extension with a 2048-bit public key.
1449   path = data_dir().AppendASCII("good2048.crx");
1450   InstallCRX(path, INSTALL_NEW);
1451   ValidatePrefKeyCount(++pref_count);
1452   ValidateIntegerPref(good2048, "state", Extension::ENABLED);
1453   ValidateIntegerPref(good2048, "location", Manifest::INTERNAL);
1454
1455   // TODO(erikkay): add more tests for many of the failure cases.
1456   // TODO(erikkay): add tests for upgrade cases.
1457 }
1458
1459 struct MockExtensionRegistryObserver
1460     : public extensions::ExtensionRegistryObserver {
1461   virtual void OnExtensionWillBeInstalled(
1462       content::BrowserContext* browser_context,
1463       const Extension* extension,
1464       bool is_update,
1465       bool from_ephemeral,
1466       const std::string& old_name) OVERRIDE {
1467     last_extension_installed = extension->id();
1468   }
1469
1470   virtual void OnExtensionUninstalled(
1471       content::BrowserContext* browser_context,
1472       const Extension* extension,
1473       extensions::UninstallReason reason) OVERRIDE {
1474     last_extension_uninstalled = extension->id();
1475   }
1476
1477   std::string last_extension_installed;
1478   std::string last_extension_uninstalled;
1479 };
1480
1481 // Test that correct notifications are sent to ExtensionRegistryObserver on
1482 // extension install and uninstall.
1483 TEST_F(ExtensionServiceTest, InstallObserverNotified) {
1484   InitializeEmptyExtensionService();
1485
1486   extensions::ExtensionRegistry* registry(
1487       extensions::ExtensionRegistry::Get(profile()));
1488   MockExtensionRegistryObserver observer;
1489   registry->AddObserver(&observer);
1490
1491   // A simple extension that should install without error.
1492   ASSERT_TRUE(observer.last_extension_installed.empty());
1493   base::FilePath path = data_dir().AppendASCII("good.crx");
1494   InstallCRX(path, INSTALL_NEW);
1495   ASSERT_EQ(good_crx, observer.last_extension_installed);
1496
1497   // Uninstall the extension.
1498   ASSERT_TRUE(observer.last_extension_uninstalled.empty());
1499   UninstallExtension(good_crx, false);
1500   ASSERT_EQ(good_crx, observer.last_extension_uninstalled);
1501
1502   registry->RemoveObserver(&observer);
1503 }
1504
1505 // Tests that flags passed to OnExternalExtensionFileFound() make it to the
1506 // extension object.
1507 TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
1508   const char kPrefFromBookmark[] = "from_bookmark";
1509
1510   InitializeEmptyExtensionService();
1511
1512   base::FilePath path = data_dir().AppendASCII("good.crx");
1513   service()->set_extensions_enabled(true);
1514
1515   // Register and install an external extension.
1516   Version version("1.0.0.0");
1517   content::WindowedNotificationObserver observer(
1518       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1519       content::NotificationService::AllSources());
1520   if (service()->OnExternalExtensionFileFound(good_crx,
1521                                               &version,
1522                                               path,
1523                                               Manifest::EXTERNAL_PREF,
1524                                               Extension::FROM_BOOKMARK,
1525                                               false /* mark_acknowledged */)) {
1526     observer.Wait();
1527   }
1528
1529   const Extension* extension = service()->GetExtensionById(good_crx, false);
1530   ASSERT_TRUE(extension);
1531   ASSERT_TRUE(extension->from_bookmark());
1532   ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
1533
1534   // Upgrade to version 2.0, the flag should be preserved.
1535   path = data_dir().AppendASCII("good2.crx");
1536   UpdateExtension(good_crx, path, ENABLED);
1537   ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
1538   extension = service()->GetExtensionById(good_crx, false);
1539   ASSERT_TRUE(extension);
1540   ASSERT_TRUE(extension->from_bookmark());
1541 }
1542
1543 // Test the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
1544 TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
1545   InitializeEmptyExtensionService();
1546
1547   base::FilePath path = data_dir().AppendASCII("good.crx");
1548   service()->set_extensions_enabled(true);
1549
1550   // Install an external extension.
1551   Version version("1.0.0.0");
1552   content::WindowedNotificationObserver observer(
1553       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1554       content::NotificationService::AllSources());
1555   if (service()->OnExternalExtensionFileFound(good_crx,
1556                                               &version,
1557                                               path,
1558                                               Manifest::EXTERNAL_PREF,
1559                                               Extension::NO_FLAGS,
1560                                               false)) {
1561     observer.Wait();
1562   }
1563
1564   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
1565
1566   // Uninstall it and check that its killbit gets set.
1567   UninstallExtension(good_crx, false);
1568   ValidateIntegerPref(good_crx, "state",
1569                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
1570
1571   // Try to re-install it externally. This should fail because of the killbit.
1572   service()->OnExternalExtensionFileFound(good_crx,
1573                                           &version,
1574                                           path,
1575                                           Manifest::EXTERNAL_PREF,
1576                                           Extension::NO_FLAGS,
1577                                           false);
1578   base::RunLoop().RunUntilIdle();
1579   ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
1580   ValidateIntegerPref(good_crx, "state",
1581                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
1582
1583   version = Version("1.0.0.1");
1584   // Repeat the same thing with a newer version of the extension.
1585   path = data_dir().AppendASCII("good2.crx");
1586   service()->OnExternalExtensionFileFound(good_crx,
1587                                           &version,
1588                                           path,
1589                                           Manifest::EXTERNAL_PREF,
1590                                           Extension::NO_FLAGS,
1591                                           false);
1592   base::RunLoop().RunUntilIdle();
1593   ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
1594   ValidateIntegerPref(good_crx, "state",
1595                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
1596
1597   // Try adding the same extension from an external update URL.
1598   ASSERT_FALSE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
1599       good_crx,
1600       std::string(),
1601       GURL("http:://fake.update/url"),
1602       Manifest::EXTERNAL_PREF_DOWNLOAD,
1603       Extension::NO_FLAGS,
1604       false));
1605
1606   ASSERT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
1607 }
1608
1609 // Test that uninstalling an external extension does not crash when
1610 // the extension could not be loaded.
1611 // This extension shown in preferences file requires an experimental permission.
1612 // It could not be loaded without such permission.
1613 TEST_F(ExtensionServiceTest, UninstallingNotLoadedExtension) {
1614   base::FilePath source_install_dir =
1615       data_dir().AppendASCII("good").AppendASCII("Extensions");
1616   // The preference contains an external extension
1617   // that requires 'experimental' permission.
1618   base::FilePath pref_path = source_install_dir
1619       .DirName()
1620       .AppendASCII("PreferencesExperimental");
1621
1622   // Aforementioned extension will not be loaded if
1623   // there is no '--enable-experimental-extension-apis' command line flag.
1624   InitializeInstalledExtensionService(pref_path, source_install_dir);
1625
1626   service()->Init();
1627
1628   // Check and try to uninstall it.
1629   // If we don't check whether the extension is loaded before we uninstall it
1630   // in CheckExternalUninstall, a crash will happen here because we will get or
1631   // dereference a NULL pointer (extension) inside UninstallExtension.
1632   MockExtensionProvider provider(NULL, Manifest::EXTERNAL_REGISTRY);
1633   service()->OnExternalProviderReady(&provider);
1634 }
1635
1636 // Test that external extensions with incorrect IDs are not installed.
1637 TEST_F(ExtensionServiceTest, FailOnWrongId) {
1638   InitializeEmptyExtensionService();
1639   base::FilePath path = data_dir().AppendASCII("good.crx");
1640   service()->set_extensions_enabled(true);
1641
1642   Version version("1.0.0.0");
1643
1644   const std::string wrong_id = all_zero;
1645   const std::string correct_id = good_crx;
1646   ASSERT_NE(correct_id, wrong_id);
1647
1648   // Install an external extension with an ID from the external
1649   // source that is not equal to the ID in the extension manifest.
1650   content::WindowedNotificationObserver observer(
1651       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1652       content::NotificationService::AllSources());
1653   service()->OnExternalExtensionFileFound(wrong_id,
1654                                           &version,
1655                                           path,
1656                                           Manifest::EXTERNAL_PREF,
1657                                           Extension::NO_FLAGS,
1658                                           false);
1659
1660   observer.Wait();
1661   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
1662
1663   // Try again with the right ID. Expect success.
1664   content::WindowedNotificationObserver observer2(
1665       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1666       content::NotificationService::AllSources());
1667   if (service()->OnExternalExtensionFileFound(correct_id,
1668                                               &version,
1669                                               path,
1670                                               Manifest::EXTERNAL_PREF,
1671                                               Extension::NO_FLAGS,
1672                                               false)) {
1673     observer2.Wait();
1674   }
1675   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
1676 }
1677
1678 // Test that external extensions with incorrect versions are not installed.
1679 TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
1680   InitializeEmptyExtensionService();
1681   base::FilePath path = data_dir().AppendASCII("good.crx");
1682   service()->set_extensions_enabled(true);
1683
1684   // Install an external extension with a version from the external
1685   // source that is not equal to the version in the extension manifest.
1686   Version wrong_version("1.2.3.4");
1687   content::WindowedNotificationObserver observer(
1688       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1689       content::NotificationService::AllSources());
1690   service()->OnExternalExtensionFileFound(good_crx,
1691                                           &wrong_version,
1692                                           path,
1693                                           Manifest::EXTERNAL_PREF,
1694                                           Extension::NO_FLAGS,
1695                                           false);
1696
1697   observer.Wait();
1698   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
1699
1700   // Try again with the right version. Expect success.
1701   service()->pending_extension_manager()->Remove(good_crx);
1702   Version correct_version("1.0.0.0");
1703   content::WindowedNotificationObserver observer2(
1704       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
1705       content::NotificationService::AllSources());
1706   if (service()->OnExternalExtensionFileFound(good_crx,
1707                                               &correct_version,
1708                                               path,
1709                                               Manifest::EXTERNAL_PREF,
1710                                               Extension::NO_FLAGS,
1711                                               false)) {
1712     observer2.Wait();
1713   }
1714   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
1715 }
1716
1717 // Install a user script (they get converted automatically to an extension)
1718 TEST_F(ExtensionServiceTest, InstallUserScript) {
1719   // The details of script conversion are tested elsewhere, this just tests
1720   // integration with ExtensionService.
1721   InitializeEmptyExtensionService();
1722
1723   base::FilePath path = data_dir().AppendASCII("user_script_basic.user.js");
1724
1725   ASSERT_TRUE(base::PathExists(path));
1726   scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service()));
1727   installer->set_allow_silent_install(true);
1728   installer->InstallUserScript(
1729       path,
1730       GURL("http://www.aaronboodman.com/scripts/user_script_basic.user.js"));
1731
1732   base::RunLoop().RunUntilIdle();
1733   std::vector<base::string16> errors = GetErrors();
1734   EXPECT_TRUE(installed_) << "Nothing was installed.";
1735   EXPECT_FALSE(was_update_) << path.value();
1736   ASSERT_EQ(1u, loaded_.size()) << "Nothing was loaded.";
1737   EXPECT_EQ(0u, errors.size()) << "There were errors: "
1738                                << JoinString(errors, ',');
1739   EXPECT_TRUE(service()->GetExtensionById(loaded_[0]->id(), false))
1740       << path.value();
1741
1742   installed_ = NULL;
1743   was_update_ = false;
1744   loaded_.clear();
1745   ExtensionErrorReporter::GetInstance()->ClearErrors();
1746 }
1747
1748 // Extensions don't install during shutdown.
1749 TEST_F(ExtensionServiceTest, InstallExtensionDuringShutdown) {
1750   InitializeEmptyExtensionService();
1751
1752   // Simulate shutdown.
1753   service()->set_browser_terminating_for_test(true);
1754
1755   base::FilePath path = data_dir().AppendASCII("good.crx");
1756   scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service()));
1757   installer->set_allow_silent_install(true);
1758   installer->InstallCrx(path);
1759   base::RunLoop().RunUntilIdle();
1760
1761   EXPECT_FALSE(installed_) << "Extension installed during shutdown.";
1762   ASSERT_EQ(0u, loaded_.size()) << "Extension loaded during shutdown.";
1763 }
1764
1765 // This tests that the granted permissions preferences are correctly set when
1766 // installing an extension.
1767 TEST_F(ExtensionServiceTest, GrantedPermissions) {
1768   InitializeEmptyExtensionService();
1769   base::FilePath path = data_dir().AppendASCII("permissions");
1770
1771   base::FilePath pem_path = path.AppendASCII("unknown.pem");
1772   path = path.AppendASCII("unknown");
1773
1774   ASSERT_TRUE(base::PathExists(pem_path));
1775   ASSERT_TRUE(base::PathExists(path));
1776
1777   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
1778
1779   APIPermissionSet expected_api_perms;
1780   URLPatternSet expected_host_perms;
1781
1782   // Make sure there aren't any granted permissions before the
1783   // extension is installed.
1784   scoped_refptr<PermissionSet> known_perms(
1785       prefs->GetGrantedPermissions(permissions_crx));
1786   EXPECT_FALSE(known_perms.get());
1787
1788   const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
1789
1790   EXPECT_EQ(0u, GetErrors().size());
1791   ASSERT_EQ(1u, registry()->enabled_extensions().size());
1792   EXPECT_EQ(permissions_crx, extension->id());
1793
1794   // Verify that the valid API permissions have been recognized.
1795   expected_api_perms.insert(APIPermission::kTab);
1796
1797   AddPattern(&expected_host_perms, "http://*.google.com/*");
1798   AddPattern(&expected_host_perms, "https://*.google.com/*");
1799   AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
1800   AddPattern(&expected_host_perms, "http://www.example.com/*");
1801
1802   known_perms = prefs->GetGrantedPermissions(extension->id());
1803   EXPECT_TRUE(known_perms.get());
1804   EXPECT_FALSE(known_perms->IsEmpty());
1805   EXPECT_EQ(expected_api_perms, known_perms->apis());
1806   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
1807   EXPECT_EQ(expected_host_perms, known_perms->effective_hosts());
1808 }
1809
1810
1811 #if !defined(OS_CHROMEOS)
1812 // This tests that the granted permissions preferences are correctly set for
1813 // default apps.
1814 TEST_F(ExtensionServiceTest, DefaultAppsGrantedPermissions) {
1815   InitializeEmptyExtensionService();
1816   base::FilePath path = data_dir().AppendASCII("permissions");
1817
1818   base::FilePath pem_path = path.AppendASCII("unknown.pem");
1819   path = path.AppendASCII("unknown");
1820
1821   ASSERT_TRUE(base::PathExists(pem_path));
1822   ASSERT_TRUE(base::PathExists(path));
1823
1824   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
1825
1826   APIPermissionSet expected_api_perms;
1827   URLPatternSet expected_host_perms;
1828
1829   // Make sure there aren't any granted permissions before the
1830   // extension is installed.
1831   scoped_refptr<PermissionSet> known_perms(
1832       prefs->GetGrantedPermissions(permissions_crx));
1833   EXPECT_FALSE(known_perms.get());
1834
1835   const Extension* extension = PackAndInstallCRX(
1836       path, pem_path, INSTALL_NEW, Extension::WAS_INSTALLED_BY_DEFAULT);
1837
1838   EXPECT_EQ(0u, GetErrors().size());
1839   ASSERT_EQ(1u, registry()->enabled_extensions().size());
1840   EXPECT_EQ(permissions_crx, extension->id());
1841
1842   // Verify that the valid API permissions have been recognized.
1843   expected_api_perms.insert(APIPermission::kTab);
1844
1845   known_perms = prefs->GetGrantedPermissions(extension->id());
1846   EXPECT_TRUE(known_perms.get());
1847   EXPECT_FALSE(known_perms->IsEmpty());
1848   EXPECT_EQ(expected_api_perms, known_perms->apis());
1849   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
1850 }
1851 #endif
1852
1853 #if !defined(OS_POSIX) || defined(OS_MACOSX)
1854 // Tests that the granted permissions full_access bit gets set correctly when
1855 // an extension contains an NPAPI plugin.
1856 // Only run this on platforms that support NPAPI plugins.
1857 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
1858   InitPluginService();
1859
1860   InitializeEmptyExtensionService();
1861
1862   ASSERT_TRUE(base::PathExists(good1_path()));
1863   const Extension* extension = PackAndInstallCRX(good1_path(), INSTALL_NEW);
1864   EXPECT_EQ(0u, GetErrors().size());
1865   EXPECT_EQ(1u, registry()->enabled_extensions().size());
1866   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
1867
1868   scoped_refptr<PermissionSet> permissions(
1869       prefs->GetGrantedPermissions(extension->id()));
1870   EXPECT_FALSE(permissions->IsEmpty());
1871   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
1872   EXPECT_FALSE(permissions->apis().empty());
1873   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
1874
1875   // Full access implies full host access too...
1876   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
1877 }
1878 #endif
1879
1880 // Tests that the extension is disabled when permissions are missing from
1881 // the extension's granted permissions preferences. (This simulates updating
1882 // the browser to a version which recognizes more permissions).
1883 TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
1884   InitializeEmptyExtensionService();
1885
1886   base::FilePath path =
1887       data_dir().AppendASCII("permissions").AppendASCII("unknown");
1888
1889   ASSERT_TRUE(base::PathExists(path));
1890
1891   const Extension* extension = PackAndInstallCRX(path, INSTALL_NEW);
1892
1893   EXPECT_EQ(0u, GetErrors().size());
1894   EXPECT_EQ(1u, registry()->enabled_extensions().size());
1895   std::string extension_id = extension->id();
1896
1897   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
1898
1899   APIPermissionSet expected_api_permissions;
1900   URLPatternSet expected_host_permissions;
1901
1902   expected_api_permissions.insert(APIPermission::kTab);
1903   AddPattern(&expected_host_permissions, "http://*.google.com/*");
1904   AddPattern(&expected_host_permissions, "https://*.google.com/*");
1905   AddPattern(&expected_host_permissions, "http://*.google.com.hk/*");
1906   AddPattern(&expected_host_permissions, "http://www.example.com/*");
1907
1908   std::set<std::string> host_permissions;
1909
1910   // Test that the extension is disabled when an API permission is missing from
1911   // the extension's granted api permissions preference. (This simulates
1912   // updating the browser to a version which recognizes a new API permission).
1913   SetPref(extension_id, "granted_permissions.api",
1914           new base::ListValue(), "granted_permissions.api");
1915   service()->ReloadExtensionsForTest();
1916
1917   EXPECT_EQ(1u, registry()->disabled_extensions().size());
1918   extension = registry()->disabled_extensions().begin()->get();
1919
1920   ASSERT_TRUE(prefs->IsExtensionDisabled(extension_id));
1921   ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
1922   ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
1923
1924   // Now grant and re-enable the extension, making sure the prefs are updated.
1925   service()->GrantPermissionsAndEnableExtension(extension);
1926
1927   ASSERT_FALSE(prefs->IsExtensionDisabled(extension_id));
1928   ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
1929   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
1930
1931   scoped_refptr<PermissionSet> current_perms(
1932       prefs->GetGrantedPermissions(extension_id));
1933   ASSERT_TRUE(current_perms.get());
1934   ASSERT_FALSE(current_perms->IsEmpty());
1935   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
1936   ASSERT_EQ(expected_api_permissions, current_perms->apis());
1937   ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
1938
1939   // Tests that the extension is disabled when a host permission is missing from
1940   // the extension's granted host permissions preference. (This simulates
1941   // updating the browser to a version which recognizes additional host
1942   // permissions).
1943   host_permissions.clear();
1944   current_perms = NULL;
1945
1946   host_permissions.insert("http://*.google.com/*");
1947   host_permissions.insert("https://*.google.com/*");
1948   host_permissions.insert("http://*.google.com.hk/*");
1949
1950   base::ListValue* api_permissions = new base::ListValue();
1951   api_permissions->Append(
1952       new base::StringValue("tabs"));
1953   SetPref(extension_id, "granted_permissions.api",
1954           api_permissions, "granted_permissions.api");
1955   SetPrefStringSet(
1956       extension_id, "granted_permissions.scriptable_host", host_permissions);
1957
1958   service()->ReloadExtensionsForTest();
1959
1960   EXPECT_EQ(1u, registry()->disabled_extensions().size());
1961   extension = registry()->disabled_extensions().begin()->get();
1962
1963   ASSERT_TRUE(prefs->IsExtensionDisabled(extension_id));
1964   ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
1965   ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
1966
1967   // Now grant and re-enable the extension, making sure the prefs are updated.
1968   service()->GrantPermissionsAndEnableExtension(extension);
1969
1970   ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
1971   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
1972
1973   current_perms = prefs->GetGrantedPermissions(extension_id);
1974   ASSERT_TRUE(current_perms.get());
1975   ASSERT_FALSE(current_perms->IsEmpty());
1976   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
1977   ASSERT_EQ(expected_api_permissions, current_perms->apis());
1978   ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
1979 }
1980
1981 // Test Packaging and installing an extension.
1982 TEST_F(ExtensionServiceTest, PackExtension) {
1983   InitializeEmptyExtensionService();
1984   base::FilePath input_directory =
1985       data_dir()
1986           .AppendASCII("good")
1987           .AppendASCII("Extensions")
1988           .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
1989           .AppendASCII("1.0.0.0");
1990
1991   base::ScopedTempDir temp_dir;
1992   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
1993   base::FilePath output_directory = temp_dir.path();
1994
1995   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
1996   base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
1997
1998   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
1999   ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
2000       privkey_path, ExtensionCreator::kNoRunFlags));
2001   ASSERT_TRUE(base::PathExists(crx_path));
2002   ASSERT_TRUE(base::PathExists(privkey_path));
2003
2004   // Repeat the run with the pem file gone, and no special flags
2005   // Should refuse to overwrite the existing crx.
2006   base::DeleteFile(privkey_path, false);
2007   ASSERT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
2008       privkey_path, ExtensionCreator::kNoRunFlags));
2009
2010   // OK, now try it with a flag to overwrite existing crx.  Should work.
2011   ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
2012       privkey_path, ExtensionCreator::kOverwriteCRX));
2013
2014   // Repeat the run allowing existing crx, but the existing pem is still
2015   // an error.  Should fail.
2016   ASSERT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
2017       privkey_path, ExtensionCreator::kOverwriteCRX));
2018
2019   ASSERT_TRUE(base::PathExists(privkey_path));
2020   InstallCRX(crx_path, INSTALL_NEW);
2021
2022   // Try packing with invalid paths.
2023   creator.reset(new ExtensionCreator());
2024   ASSERT_FALSE(
2025       creator->Run(base::FilePath(), base::FilePath(), base::FilePath(),
2026                    base::FilePath(), ExtensionCreator::kOverwriteCRX));
2027
2028   // Try packing an empty directory. Should fail because an empty directory is
2029   // not a valid extension.
2030   base::ScopedTempDir temp_dir2;
2031   ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
2032   creator.reset(new ExtensionCreator());
2033   ASSERT_FALSE(creator->Run(temp_dir2.path(), crx_path, privkey_path,
2034                             base::FilePath(), ExtensionCreator::kOverwriteCRX));
2035
2036   // Try packing with an invalid manifest.
2037   std::string invalid_manifest_content = "I am not a manifest.";
2038   ASSERT_TRUE(base::WriteFile(
2039       temp_dir2.path().Append(extensions::kManifestFilename),
2040       invalid_manifest_content.c_str(), invalid_manifest_content.size()));
2041   creator.reset(new ExtensionCreator());
2042   ASSERT_FALSE(creator->Run(temp_dir2.path(), crx_path, privkey_path,
2043                             base::FilePath(), ExtensionCreator::kOverwriteCRX));
2044
2045   // Try packing with a private key that is a valid key, but invalid for the
2046   // extension.
2047   base::FilePath bad_private_key_dir =
2048       data_dir().AppendASCII("bad_private_key");
2049   crx_path = output_directory.AppendASCII("bad_private_key.crx");
2050   privkey_path = data_dir().AppendASCII("bad_private_key.pem");
2051   ASSERT_FALSE(creator->Run(bad_private_key_dir, crx_path, base::FilePath(),
2052       privkey_path, ExtensionCreator::kOverwriteCRX));
2053 }
2054
2055 // Test Packaging and installing an extension whose name contains punctuation.
2056 TEST_F(ExtensionServiceTest, PackPunctuatedExtension) {
2057   InitializeEmptyExtensionService();
2058   base::FilePath input_directory = data_dir()
2059                                        .AppendASCII("good")
2060                                        .AppendASCII("Extensions")
2061                                        .AppendASCII(good0)
2062                                        .AppendASCII("1.0.0.0");
2063
2064   base::ScopedTempDir temp_dir;
2065   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
2066
2067   // Extension names containing punctuation, and the expected names for the
2068   // packed extensions.
2069   const base::FilePath punctuated_names[] = {
2070     base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods")),
2071     base::FilePath(FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod")),
2072     base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname/")).
2073         NormalizePathSeparators(),
2074   };
2075   const base::FilePath expected_crx_names[] = {
2076     base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods.crx")),
2077     base::FilePath(
2078         FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.crx")),
2079     base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname.crx")),
2080   };
2081   const base::FilePath expected_private_key_names[] = {
2082     base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods.pem")),
2083     base::FilePath(
2084         FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.pem")),
2085     base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname.pem")),
2086   };
2087
2088   for (size_t i = 0; i < arraysize(punctuated_names); ++i) {
2089     SCOPED_TRACE(punctuated_names[i].value().c_str());
2090     base::FilePath output_dir = temp_dir.path().Append(punctuated_names[i]);
2091
2092     // Copy the extension into the output directory, as PackExtensionJob doesn't
2093     // let us choose where to output the packed extension.
2094     ASSERT_TRUE(base::CopyDirectory(input_directory, output_dir, true));
2095
2096     base::FilePath expected_crx_path =
2097         temp_dir.path().Append(expected_crx_names[i]);
2098     base::FilePath expected_private_key_path =
2099         temp_dir.path().Append(expected_private_key_names[i]);
2100     PackExtensionTestClient pack_client(expected_crx_path,
2101                                         expected_private_key_path);
2102     scoped_refptr<extensions::PackExtensionJob> packer(
2103         new extensions::PackExtensionJob(&pack_client, output_dir,
2104                                          base::FilePath(),
2105                                          ExtensionCreator::kOverwriteCRX));
2106     packer->Start();
2107
2108     // The packer will post a notification task to the current thread's message
2109     // loop when it is finished.  We manually run the loop here so that we
2110     // block and catch the notification; otherwise, the process would exit.
2111     // This call to |Run()| is matched by a call to |Quit()| in the
2112     // |PackExtensionTestClient|'s notification handling code.
2113     base::MessageLoop::current()->Run();
2114
2115     if (HasFatalFailure())
2116       return;
2117
2118     InstallCRX(expected_crx_path, INSTALL_NEW);
2119   }
2120 }
2121
2122 TEST_F(ExtensionServiceTest, PackExtensionContainingKeyFails) {
2123   InitializeEmptyExtensionService();
2124
2125   base::ScopedTempDir extension_temp_dir;
2126   ASSERT_TRUE(extension_temp_dir.CreateUniqueTempDir());
2127   base::FilePath input_directory = extension_temp_dir.path().AppendASCII("ext");
2128   ASSERT_TRUE(
2129       base::CopyDirectory(data_dir()
2130                               .AppendASCII("good")
2131                               .AppendASCII("Extensions")
2132                               .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
2133                               .AppendASCII("1.0.0.0"),
2134                           input_directory,
2135                           /*recursive=*/true));
2136
2137   base::ScopedTempDir output_temp_dir;
2138   ASSERT_TRUE(output_temp_dir.CreateUniqueTempDir());
2139   base::FilePath output_directory = output_temp_dir.path();
2140
2141   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
2142   base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
2143
2144   // Pack the extension once to get a private key.
2145   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
2146   ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
2147       privkey_path, ExtensionCreator::kNoRunFlags))
2148       << creator->error_message();
2149   ASSERT_TRUE(base::PathExists(crx_path));
2150   ASSERT_TRUE(base::PathExists(privkey_path));
2151
2152   base::DeleteFile(crx_path, false);
2153   // Move the pem file into the extension.
2154   base::Move(privkey_path,
2155                   input_directory.AppendASCII("privkey.pem"));
2156
2157   // This pack should fail because of the contained private key.
2158   EXPECT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
2159       privkey_path, ExtensionCreator::kNoRunFlags));
2160   EXPECT_THAT(creator->error_message(),
2161               testing::ContainsRegex(
2162                   "extension includes the key file.*privkey.pem"));
2163 }
2164
2165 // Test Packaging and installing an extension using an openssl generated key.
2166 // The openssl is generated with the following:
2167 // > openssl genrsa -out privkey.pem 1024
2168 // > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem
2169 // The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a
2170 // PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
2171 TEST_F(ExtensionServiceTest, PackExtensionOpenSSLKey) {
2172   InitializeEmptyExtensionService();
2173   base::FilePath input_directory =
2174       data_dir()
2175           .AppendASCII("good")
2176           .AppendASCII("Extensions")
2177           .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
2178           .AppendASCII("1.0.0.0");
2179   base::FilePath privkey_path(
2180       data_dir().AppendASCII("openssl_privkey_asn1.pem"));
2181   ASSERT_TRUE(base::PathExists(privkey_path));
2182
2183   base::ScopedTempDir temp_dir;
2184   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
2185   base::FilePath output_directory = temp_dir.path();
2186
2187   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
2188
2189   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
2190   ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
2191       base::FilePath(), ExtensionCreator::kOverwriteCRX));
2192
2193   InstallCRX(crx_path, INSTALL_NEW);
2194 }
2195
2196 #if defined(THREAD_SANITIZER)
2197 // Flaky under Tsan. http://crbug.com/377702
2198 #define MAYBE_InstallTheme DISABLED_InstallTheme
2199 #else
2200 #define MAYBE_InstallTheme InstallTheme
2201 #endif
2202
2203 TEST_F(ExtensionServiceTest, MAYBE_InstallTheme) {
2204   InitializeEmptyExtensionService();
2205   service()->Init();
2206
2207   // A theme.
2208   base::FilePath path = data_dir().AppendASCII("theme.crx");
2209   InstallCRX(path, INSTALL_NEW);
2210   int pref_count = 0;
2211   ValidatePrefKeyCount(++pref_count);
2212   ValidateIntegerPref(theme_crx, "state", Extension::ENABLED);
2213   ValidateIntegerPref(theme_crx, "location", Manifest::INTERNAL);
2214
2215   // A theme when extensions are disabled. Themes can be installed, even when
2216   // extensions are disabled.
2217   service()->set_extensions_enabled(false);
2218   path = data_dir().AppendASCII("theme2.crx");
2219   InstallCRX(path, INSTALL_NEW);
2220   ValidatePrefKeyCount(++pref_count);
2221   ValidateIntegerPref(theme2_crx, "state", Extension::ENABLED);
2222   ValidateIntegerPref(theme2_crx, "location", Manifest::INTERNAL);
2223
2224   // A theme with extension elements. Themes cannot have extension elements,
2225   // so any such elements (like content scripts) should be ignored.
2226   service()->set_extensions_enabled(true);
2227   {
2228     path = data_dir().AppendASCII("theme_with_extension.crx");
2229     const Extension* extension = InstallCRX(path, INSTALL_NEW);
2230     ValidatePrefKeyCount(++pref_count);
2231     ASSERT_TRUE(extension);
2232     EXPECT_TRUE(extension->is_theme());
2233     EXPECT_EQ(
2234         0u,
2235         extensions::ContentScriptsInfo::GetContentScripts(extension).size());
2236   }
2237
2238   // A theme with image resources missing (misspelt path).
2239   path = data_dir().AppendASCII("theme_missing_image.crx");
2240   InstallCRX(path, INSTALL_FAILED);
2241   ValidatePrefKeyCount(pref_count);
2242 }
2243
2244 TEST_F(ExtensionServiceTest, LoadLocalizedTheme) {
2245   // Load.
2246   InitializeEmptyExtensionService();
2247   service()->Init();
2248
2249   base::FilePath extension_path = data_dir().AppendASCII("theme_i18n");
2250
2251   extensions::UnpackedInstaller::Create(service())->Load(extension_path);
2252   base::RunLoop().RunUntilIdle();
2253   EXPECT_EQ(0u, GetErrors().size());
2254   ASSERT_EQ(1u, loaded_.size());
2255   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2256   const Extension* theme = registry()->enabled_extensions().begin()->get();
2257   EXPECT_EQ("name", theme->name());
2258   EXPECT_EQ("description", theme->description());
2259
2260   // Cleanup the "Cached Theme.pak" file. Ideally, this would be installed in a
2261   // temporary directory, but it automatically installs to the extension's
2262   // directory, and we don't want to copy the whole extension for a unittest.
2263   base::FilePath theme_file = extension_path.Append(chrome::kThemePackFilename);
2264   ASSERT_TRUE(base::PathExists(theme_file));
2265   ASSERT_TRUE(base::DeleteFile(theme_file, false));  // Not recursive.
2266 }
2267
2268 // Tests that we can change the ID of an unpacked extension by adding a key
2269 // to its manifest.
2270 TEST_F(ExtensionServiceTest, UnpackedExtensionCanChangeID) {
2271   InitializeEmptyExtensionService();
2272
2273   base::ScopedTempDir temp;
2274   ASSERT_TRUE(temp.CreateUniqueTempDir());
2275
2276   base::FilePath extension_path = temp.path();
2277   base::FilePath manifest_path =
2278       extension_path.Append(extensions::kManifestFilename);
2279   base::FilePath manifest_no_key =
2280       data_dir().AppendASCII("unpacked").AppendASCII("manifest_no_key.json");
2281
2282   base::FilePath manifest_with_key =
2283       data_dir().AppendASCII("unpacked").AppendASCII("manifest_with_key.json");
2284
2285   ASSERT_TRUE(base::PathExists(manifest_no_key));
2286   ASSERT_TRUE(base::PathExists(manifest_with_key));
2287
2288   // Load the unpacked extension with no key.
2289   base::CopyFile(manifest_no_key, manifest_path);
2290   extensions::UnpackedInstaller::Create(service())->Load(extension_path);
2291
2292   base::RunLoop().RunUntilIdle();
2293   EXPECT_EQ(0u, GetErrors().size());
2294   ASSERT_EQ(1u, loaded_.size());
2295   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2296
2297   // Add the key to the manifest.
2298   base::CopyFile(manifest_with_key, manifest_path);
2299   loaded_.clear();
2300
2301   // Reload the extensions.
2302   service()->ReloadExtensionsForTest();
2303   const Extension* extension = service()->GetExtensionById(unpacked, false);
2304   EXPECT_EQ(unpacked, extension->id());
2305   ASSERT_EQ(1u, loaded_.size());
2306
2307   // TODO(jstritar): Right now this just makes sure we don't crash and burn, but
2308   // we should also test that preferences are preserved.
2309 }
2310
2311 #if defined(OS_POSIX)
2312 TEST_F(ExtensionServiceTest, UnpackedExtensionMayContainSymlinkedFiles) {
2313   base::FilePath source_data_dir =
2314       data_dir().AppendASCII("unpacked").AppendASCII("symlinks_allowed");
2315
2316   // Paths to test data files.
2317   base::FilePath source_manifest = source_data_dir.AppendASCII("manifest.json");
2318   ASSERT_TRUE(base::PathExists(source_manifest));
2319   base::FilePath source_icon = source_data_dir.AppendASCII("icon.png");
2320   ASSERT_TRUE(base::PathExists(source_icon));
2321
2322   // Set up the temporary extension directory.
2323   base::ScopedTempDir temp;
2324   ASSERT_TRUE(temp.CreateUniqueTempDir());
2325   base::FilePath extension_path = temp.path();
2326   base::FilePath manifest = extension_path.Append(
2327       extensions::kManifestFilename);
2328   base::FilePath icon_symlink = extension_path.AppendASCII("icon.png");
2329   base::CopyFile(source_manifest, manifest);
2330   base::CreateSymbolicLink(source_icon, icon_symlink);
2331
2332   // Load extension.
2333   InitializeEmptyExtensionService();
2334   extensions::UnpackedInstaller::Create(service())->Load(extension_path);
2335   base::RunLoop().RunUntilIdle();
2336
2337   EXPECT_TRUE(GetErrors().empty());
2338   ASSERT_EQ(1u, loaded_.size());
2339   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2340 }
2341 #endif
2342
2343 TEST_F(ExtensionServiceTest, UnpackedExtensionMayNotHaveUnderscore) {
2344   InitializeEmptyExtensionService();
2345   base::FilePath extension_path = data_dir().AppendASCII("underscore_name");
2346   extensions::UnpackedInstaller::Create(service())->Load(extension_path);
2347   base::RunLoop().RunUntilIdle();
2348   EXPECT_EQ(1u, GetErrors().size());
2349   EXPECT_EQ(0u, registry()->enabled_extensions().size());
2350 }
2351
2352 TEST_F(ExtensionServiceTest, InstallLocalizedTheme) {
2353   InitializeEmptyExtensionService();
2354   service()->Init();
2355
2356   base::FilePath theme_path = data_dir().AppendASCII("theme_i18n");
2357
2358   const Extension* theme = PackAndInstallCRX(theme_path, INSTALL_NEW);
2359
2360   EXPECT_EQ(0u, GetErrors().size());
2361   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2362   EXPECT_EQ("name", theme->name());
2363   EXPECT_EQ("description", theme->description());
2364 }
2365
2366 TEST_F(ExtensionServiceTest, InstallApps) {
2367   InitializeEmptyExtensionService();
2368
2369   // An empty app.
2370   const Extension* app =
2371       PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
2372   int pref_count = 0;
2373   ValidatePrefKeyCount(++pref_count);
2374   ASSERT_EQ(1u, registry()->enabled_extensions().size());
2375   ValidateIntegerPref(app->id(), "state", Extension::ENABLED);
2376   ValidateIntegerPref(app->id(), "location", Manifest::INTERNAL);
2377
2378   // Another app with non-overlapping extent. Should succeed.
2379   PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
2380   ValidatePrefKeyCount(++pref_count);
2381
2382   // A third app whose extent overlaps the first. Should fail.
2383   PackAndInstallCRX(data_dir().AppendASCII("app3"), INSTALL_FAILED);
2384   ValidatePrefKeyCount(pref_count);
2385 }
2386
2387 // Tests that file access is OFF by default.
2388 TEST_F(ExtensionServiceTest, DefaultFileAccess) {
2389   InitializeEmptyExtensionService();
2390   const Extension* extension = PackAndInstallCRX(
2391       data_dir().AppendASCII("permissions").AppendASCII("files"), INSTALL_NEW);
2392   EXPECT_EQ(0u, GetErrors().size());
2393   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2394   EXPECT_FALSE(
2395       ExtensionPrefs::Get(profile())->AllowFileAccess(extension->id()));
2396 }
2397
2398 TEST_F(ExtensionServiceTest, UpdateApps) {
2399   InitializeEmptyExtensionService();
2400   base::FilePath extensions_path = data_dir().AppendASCII("app_update");
2401
2402   // First install v1 of a hosted app.
2403   const Extension* extension =
2404       InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
2405   ASSERT_EQ(1u, registry()->enabled_extensions().size());
2406   std::string id = extension->id();
2407   ASSERT_EQ(std::string("1"), extension->version()->GetString());
2408
2409   // Now try updating to v2.
2410   UpdateExtension(id,
2411                   extensions_path.AppendASCII("v2.crx"),
2412                   ENABLED);
2413   ASSERT_EQ(std::string("2"),
2414             service()->GetExtensionById(id, false)->version()->GetString());
2415 }
2416
2417 // Verifies that the NTP page and launch ordinals are kept when updating apps.
2418 TEST_F(ExtensionServiceTest, UpdateAppsRetainOrdinals) {
2419   InitializeEmptyExtensionService();
2420   AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
2421   base::FilePath extensions_path = data_dir().AppendASCII("app_update");
2422
2423   // First install v1 of a hosted app.
2424   const Extension* extension =
2425       InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
2426   ASSERT_EQ(1u, registry()->enabled_extensions().size());
2427   std::string id = extension->id();
2428   ASSERT_EQ(std::string("1"), extension->version()->GetString());
2429
2430   // Modify the ordinals so we can distinguish them from the defaults.
2431   syncer::StringOrdinal new_page_ordinal =
2432       sorting->GetPageOrdinal(id).CreateAfter();
2433   syncer::StringOrdinal new_launch_ordinal =
2434       sorting->GetAppLaunchOrdinal(id).CreateBefore();
2435
2436   sorting->SetPageOrdinal(id, new_page_ordinal);
2437   sorting->SetAppLaunchOrdinal(id, new_launch_ordinal);
2438
2439   // Now try updating to v2.
2440   UpdateExtension(id, extensions_path.AppendASCII("v2.crx"), ENABLED);
2441   ASSERT_EQ(std::string("2"),
2442             service()->GetExtensionById(id, false)->version()->GetString());
2443
2444   // Verify that the ordinals match.
2445   ASSERT_TRUE(new_page_ordinal.Equals(sorting->GetPageOrdinal(id)));
2446   ASSERT_TRUE(new_launch_ordinal.Equals(sorting->GetAppLaunchOrdinal(id)));
2447 }
2448
2449 // Ensures that the CWS has properly initialized ordinals.
2450 TEST_F(ExtensionServiceTest, EnsureCWSOrdinalsInitialized) {
2451   InitializeEmptyExtensionService();
2452   service()->component_loader()->Add(
2453       IDR_WEBSTORE_MANIFEST, base::FilePath(FILE_PATH_LITERAL("web_store")));
2454   service()->Init();
2455
2456   AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
2457   EXPECT_TRUE(
2458       sorting->GetPageOrdinal(extensions::kWebStoreAppId).IsValid());
2459   EXPECT_TRUE(
2460       sorting->GetAppLaunchOrdinal(extensions::kWebStoreAppId).IsValid());
2461 }
2462
2463 TEST_F(ExtensionServiceTest, InstallAppsWithUnlimitedStorage) {
2464   InitializeEmptyExtensionService();
2465   EXPECT_TRUE(registry()->enabled_extensions().is_empty());
2466
2467   int pref_count = 0;
2468
2469   // Install app1 with unlimited storage.
2470   const Extension* extension =
2471       PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
2472   ValidatePrefKeyCount(++pref_count);
2473   ASSERT_EQ(1u, registry()->enabled_extensions().size());
2474   const std::string id1 = extension->id();
2475   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
2476       APIPermission::kUnlimitedStorage));
2477   EXPECT_TRUE(extension->web_extent().MatchesURL(
2478       extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
2479   const GURL origin1(
2480       extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
2481   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
2482       origin1));
2483
2484   // Install app2 from the same origin with unlimited storage.
2485   extension = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
2486   ValidatePrefKeyCount(++pref_count);
2487   ASSERT_EQ(2u, registry()->enabled_extensions().size());
2488   const std::string id2 = extension->id();
2489   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
2490       APIPermission::kUnlimitedStorage));
2491   EXPECT_TRUE(extension->web_extent().MatchesURL(
2492       extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
2493   const GURL origin2(
2494       extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
2495   EXPECT_EQ(origin1, origin2);
2496   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
2497       origin2));
2498
2499   // Uninstall one of them, unlimited storage should still be granted
2500   // to the origin.
2501   UninstallExtension(id1, false);
2502   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2503   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
2504       origin1));
2505
2506   // Uninstall the other, unlimited storage should be revoked.
2507   UninstallExtension(id2, false);
2508   EXPECT_EQ(0u, registry()->enabled_extensions().size());
2509   EXPECT_FALSE(
2510       profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
2511           origin2));
2512 }
2513
2514 TEST_F(ExtensionServiceTest, InstallAppsAndCheckStorageProtection) {
2515   InitializeEmptyExtensionService();
2516   EXPECT_TRUE(registry()->enabled_extensions().is_empty());
2517
2518   int pref_count = 0;
2519
2520   const Extension* extension =
2521       PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
2522   ValidatePrefKeyCount(++pref_count);
2523   ASSERT_EQ(1u, registry()->enabled_extensions().size());
2524   EXPECT_TRUE(extension->is_app());
2525   const std::string id1 = extension->id();
2526   const GURL origin1(
2527       extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
2528   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
2529       origin1));
2530
2531   // App 4 has a different origin (maps.google.com).
2532   extension = PackAndInstallCRX(data_dir().AppendASCII("app4"), INSTALL_NEW);
2533   ValidatePrefKeyCount(++pref_count);
2534   ASSERT_EQ(2u, registry()->enabled_extensions().size());
2535   const std::string id2 = extension->id();
2536   const GURL origin2(
2537       extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
2538   ASSERT_NE(origin1, origin2);
2539   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
2540       origin2));
2541
2542   UninstallExtension(id1, false);
2543   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2544
2545   UninstallExtension(id2, false);
2546
2547   EXPECT_TRUE(registry()->enabled_extensions().is_empty());
2548   EXPECT_FALSE(
2549       profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
2550           origin1));
2551   EXPECT_FALSE(
2552       profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
2553           origin2));
2554 }
2555
2556 // Test that when an extension version is reinstalled, nothing happens.
2557 TEST_F(ExtensionServiceTest, Reinstall) {
2558   InitializeEmptyExtensionService();
2559
2560   // A simple extension that should install without error.
2561   base::FilePath path = data_dir().AppendASCII("good.crx");
2562   InstallCRX(path, INSTALL_NEW);
2563
2564   ValidatePrefKeyCount(1);
2565   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
2566   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
2567
2568   // Reinstall the same version, it should overwrite the previous one.
2569   InstallCRX(path, INSTALL_UPDATED);
2570
2571   ValidatePrefKeyCount(1);
2572   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
2573   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
2574 }
2575
2576 // Test that we can determine if extensions came from the
2577 // Chrome web store.
2578 TEST_F(ExtensionServiceTest, FromWebStore) {
2579   InitializeEmptyExtensionService();
2580
2581   // A simple extension that should install without error.
2582   base::FilePath path = data_dir().AppendASCII("good.crx");
2583   // Not from web store.
2584   const Extension* extension = InstallCRX(path, INSTALL_NEW);
2585   std::string id = extension->id();
2586
2587   ValidatePrefKeyCount(1);
2588   ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", false));
2589   ASSERT_FALSE(extension->from_webstore());
2590
2591   // Test install from web store.
2592   InstallCRXFromWebStore(path, INSTALL_UPDATED);  // From web store.
2593
2594   ValidatePrefKeyCount(1);
2595   ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
2596
2597   // Reload so extension gets reinitialized with new value.
2598   service()->ReloadExtensionsForTest();
2599   extension = service()->GetExtensionById(id, false);
2600   ASSERT_TRUE(extension->from_webstore());
2601
2602   // Upgrade to version 2.0
2603   path = data_dir().AppendASCII("good2.crx");
2604   UpdateExtension(good_crx, path, ENABLED);
2605   ValidatePrefKeyCount(1);
2606   ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
2607 }
2608
2609 // Test upgrading a signed extension.
2610 TEST_F(ExtensionServiceTest, UpgradeSignedGood) {
2611   InitializeEmptyExtensionService();
2612
2613   base::FilePath path = data_dir().AppendASCII("good.crx");
2614   const Extension* extension = InstallCRX(path, INSTALL_NEW);
2615   std::string id = extension->id();
2616
2617   ASSERT_EQ("1.0.0.0", extension->version()->GetString());
2618   ASSERT_EQ(0u, GetErrors().size());
2619
2620   // Upgrade to version 1.0.0.1.
2621   // Also test that the extension's old and new title are correctly retrieved.
2622   path = data_dir().AppendASCII("good2.crx");
2623   InstallCRX(path, INSTALL_UPDATED, Extension::NO_FLAGS, "My extension 1");
2624   extension = service()->GetExtensionById(id, false);
2625
2626   ASSERT_EQ("1.0.0.1", extension->version()->GetString());
2627   ASSERT_EQ("My updated extension 1", extension->name());
2628   ASSERT_EQ(0u, GetErrors().size());
2629 }
2630
2631 // Test upgrading a signed extension with a bad signature.
2632 TEST_F(ExtensionServiceTest, UpgradeSignedBad) {
2633   InitializeEmptyExtensionService();
2634
2635   base::FilePath path = data_dir().AppendASCII("good.crx");
2636   InstallCRX(path, INSTALL_NEW);
2637
2638   // Try upgrading with a bad signature. This should fail during the unpack,
2639   // because the key will not match the signature.
2640   path = data_dir().AppendASCII("bad_signature.crx");
2641   InstallCRX(path, INSTALL_FAILED);
2642 }
2643
2644 // Test a normal update via the UpdateExtension API
2645 TEST_F(ExtensionServiceTest, UpdateExtension) {
2646   InitializeEmptyExtensionService();
2647
2648   base::FilePath path = data_dir().AppendASCII("good.crx");
2649
2650   const Extension* good = InstallCRX(path, INSTALL_NEW);
2651   ASSERT_EQ("1.0.0.0", good->VersionString());
2652   ASSERT_EQ(good_crx, good->id());
2653
2654   path = data_dir().AppendASCII("good2.crx");
2655   UpdateExtension(good_crx, path, ENABLED);
2656   ASSERT_EQ(
2657       "1.0.0.1",
2658       service()->GetExtensionById(good_crx, false)->version()->GetString());
2659 }
2660
2661 // Extensions should not be updated during browser shutdown.
2662 TEST_F(ExtensionServiceTest, UpdateExtensionDuringShutdown) {
2663   InitializeEmptyExtensionService();
2664
2665   // Install an extension.
2666   base::FilePath path = data_dir().AppendASCII("good.crx");
2667   const Extension* good = InstallCRX(path, INSTALL_NEW);
2668   ASSERT_EQ(good_crx, good->id());
2669
2670   // Simulate shutdown.
2671   service()->set_browser_terminating_for_test(true);
2672
2673   // Update should fail and extension should not be updated.
2674   path = data_dir().AppendASCII("good2.crx");
2675   bool updated = service()->UpdateExtension(good_crx, path, true, NULL);
2676   ASSERT_FALSE(updated);
2677   ASSERT_EQ(
2678       "1.0.0.0",
2679       service()->GetExtensionById(good_crx, false)->version()->GetString());
2680 }
2681
2682 // Test updating a not-already-installed extension - this should fail
2683 TEST_F(ExtensionServiceTest, UpdateNotInstalledExtension) {
2684   InitializeEmptyExtensionService();
2685
2686   base::FilePath path = data_dir().AppendASCII("good.crx");
2687   UpdateExtension(good_crx, path, UPDATED);
2688   base::RunLoop().RunUntilIdle();
2689
2690   ASSERT_EQ(0u, registry()->enabled_extensions().size());
2691   ASSERT_FALSE(installed_);
2692   ASSERT_EQ(0u, loaded_.size());
2693 }
2694
2695 // Makes sure you can't downgrade an extension via UpdateExtension
2696 TEST_F(ExtensionServiceTest, UpdateWillNotDowngrade) {
2697   InitializeEmptyExtensionService();
2698
2699   base::FilePath path = data_dir().AppendASCII("good2.crx");
2700
2701   const Extension* good = InstallCRX(path, INSTALL_NEW);
2702   ASSERT_EQ("1.0.0.1", good->VersionString());
2703   ASSERT_EQ(good_crx, good->id());
2704
2705   // Change path from good2.crx -> good.crx
2706   path = data_dir().AppendASCII("good.crx");
2707   UpdateExtension(good_crx, path, FAILED);
2708   ASSERT_EQ(
2709       "1.0.0.1",
2710       service()->GetExtensionById(good_crx, false)->version()->GetString());
2711 }
2712
2713 // Make sure calling update with an identical version does nothing
2714 TEST_F(ExtensionServiceTest, UpdateToSameVersionIsNoop) {
2715   InitializeEmptyExtensionService();
2716
2717   base::FilePath path = data_dir().AppendASCII("good.crx");
2718
2719   const Extension* good = InstallCRX(path, INSTALL_NEW);
2720   ASSERT_EQ(good_crx, good->id());
2721   UpdateExtension(good_crx, path, FAILED_SILENTLY);
2722 }
2723
2724 // Tests that updating an extension does not clobber old state.
2725 TEST_F(ExtensionServiceTest, UpdateExtensionPreservesState) {
2726   InitializeEmptyExtensionService();
2727
2728   base::FilePath path = data_dir().AppendASCII("good.crx");
2729
2730   const Extension* good = InstallCRX(path, INSTALL_NEW);
2731   ASSERT_EQ("1.0.0.0", good->VersionString());
2732   ASSERT_EQ(good_crx, good->id());
2733
2734   // Disable it and allow it to run in incognito. These settings should carry
2735   // over to the updated version.
2736   service()->DisableExtension(good->id(), Extension::DISABLE_USER_ACTION);
2737   extensions::util::SetIsIncognitoEnabled(good->id(), profile(), true);
2738   ExtensionPrefs::Get(profile())
2739       ->SetDidExtensionEscalatePermissions(good, true);
2740
2741   path = data_dir().AppendASCII("good2.crx");
2742   UpdateExtension(good_crx, path, INSTALLED);
2743   ASSERT_EQ(1u, registry()->disabled_extensions().size());
2744   const Extension* good2 = service()->GetExtensionById(good_crx, true);
2745   ASSERT_EQ("1.0.0.1", good2->version()->GetString());
2746   EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good2->id(), profile()));
2747   EXPECT_TRUE(ExtensionPrefs::Get(profile())
2748                   ->DidExtensionEscalatePermissions(good2->id()));
2749 }
2750
2751 // Tests that updating preserves extension location.
2752 TEST_F(ExtensionServiceTest, UpdateExtensionPreservesLocation) {
2753   InitializeEmptyExtensionService();
2754
2755   base::FilePath path = data_dir().AppendASCII("good.crx");
2756
2757   const Extension* good =
2758       InstallCRXWithLocation(path, Manifest::EXTERNAL_PREF, INSTALL_NEW);
2759
2760   ASSERT_EQ("1.0.0.0", good->VersionString());
2761   ASSERT_EQ(good_crx, good->id());
2762
2763   path = data_dir().AppendASCII("good2.crx");
2764   UpdateExtension(good_crx, path, ENABLED);
2765   const Extension* good2 = service()->GetExtensionById(good_crx, false);
2766   ASSERT_EQ("1.0.0.1", good2->version()->GetString());
2767   EXPECT_EQ(good2->location(), Manifest::EXTERNAL_PREF);
2768 }
2769
2770 // Makes sure that LOAD extension types can downgrade.
2771 TEST_F(ExtensionServiceTest, LoadExtensionsCanDowngrade) {
2772   InitializeEmptyExtensionService();
2773
2774   base::ScopedTempDir temp;
2775   ASSERT_TRUE(temp.CreateUniqueTempDir());
2776
2777   // We'll write the extension manifest dynamically to a temporary path
2778   // to make it easier to change the version number.
2779   base::FilePath extension_path = temp.path();
2780   base::FilePath manifest_path =
2781       extension_path.Append(extensions::kManifestFilename);
2782   ASSERT_FALSE(base::PathExists(manifest_path));
2783
2784   // Start with version 2.0.
2785   base::DictionaryValue manifest;
2786   manifest.SetString("version", "2.0");
2787   manifest.SetString("name", "LOAD Downgrade Test");
2788   manifest.SetInteger("manifest_version", 2);
2789
2790   JSONFileValueSerializer serializer(manifest_path);
2791   ASSERT_TRUE(serializer.Serialize(manifest));
2792
2793   extensions::UnpackedInstaller::Create(service())->Load(extension_path);
2794   base::RunLoop().RunUntilIdle();
2795
2796   EXPECT_EQ(0u, GetErrors().size());
2797   ASSERT_EQ(1u, loaded_.size());
2798   EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
2799   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2800   EXPECT_EQ("2.0", loaded_[0]->VersionString());
2801
2802   // Now set the version number to 1.0, reload the extensions and verify that
2803   // the downgrade was accepted.
2804   manifest.SetString("version", "1.0");
2805   ASSERT_TRUE(serializer.Serialize(manifest));
2806
2807   extensions::UnpackedInstaller::Create(service())->Load(extension_path);
2808   base::RunLoop().RunUntilIdle();
2809
2810   EXPECT_EQ(0u, GetErrors().size());
2811   ASSERT_EQ(1u, loaded_.size());
2812   EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
2813   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2814   EXPECT_EQ("1.0", loaded_[0]->VersionString());
2815 }
2816
2817 #if !defined(OS_POSIX) || defined(OS_MACOSX)
2818 // LOAD extensions with plugins require approval.
2819 // Only run this on platforms that support NPAPI plugins.
2820 TEST_F(ExtensionServiceTest, LoadExtensionsWithPlugins) {
2821   base::FilePath extension_with_plugin_path = good1_path();
2822   base::FilePath extension_no_plugin_path = good2_path();
2823
2824   InitPluginService();
2825   InitializeEmptyExtensionService();
2826   InitializeProcessManager();
2827   service()->set_show_extensions_prompts(true);
2828
2829   // Start by canceling any install prompts.
2830   ExtensionInstallPrompt::g_auto_confirm_for_tests =
2831       ExtensionInstallPrompt::CANCEL;
2832
2833   // The extension that has a plugin should not install.
2834   extensions::UnpackedInstaller::Create(service())
2835       ->Load(extension_with_plugin_path);
2836   base::RunLoop().RunUntilIdle();
2837   EXPECT_EQ(0u, GetErrors().size());
2838   EXPECT_EQ(0u, loaded_.size());
2839   EXPECT_EQ(0u, registry()->enabled_extensions().size());
2840   EXPECT_EQ(0u, registry()->disabled_extensions().size());
2841
2842   // But the extension with no plugin should since there's no prompt.
2843   ExtensionErrorReporter::GetInstance()->ClearErrors();
2844   extensions::UnpackedInstaller::Create(service())
2845       ->Load(extension_no_plugin_path);
2846   base::RunLoop().RunUntilIdle();
2847   EXPECT_EQ(0u, GetErrors().size());
2848   EXPECT_EQ(1u, loaded_.size());
2849   EXPECT_EQ(1u, registry()->enabled_extensions().size());
2850   EXPECT_EQ(0u, registry()->disabled_extensions().size());
2851   EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
2852
2853   // The plugin extension should install if we accept the dialog.
2854   ExtensionInstallPrompt::g_auto_confirm_for_tests =
2855       ExtensionInstallPrompt::ACCEPT;
2856
2857   ExtensionErrorReporter::GetInstance()->ClearErrors();
2858   extensions::UnpackedInstaller::Create(service())
2859       ->Load(extension_with_plugin_path);
2860   base::RunLoop().RunUntilIdle();
2861   EXPECT_EQ(0u, GetErrors().size());
2862   EXPECT_EQ(2u, loaded_.size());
2863   EXPECT_EQ(2u, registry()->enabled_extensions().size());
2864   EXPECT_EQ(0u, registry()->disabled_extensions().size());
2865   EXPECT_TRUE(registry()->enabled_extensions().Contains(good1));
2866   EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
2867
2868   // Make sure the granted permissions have been setup.
2869   scoped_refptr<PermissionSet> permissions(
2870       ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1));
2871   EXPECT_FALSE(permissions->IsEmpty());
2872   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
2873   EXPECT_FALSE(permissions->apis().empty());
2874   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
2875
2876   // We should be able to reload the extension without getting another prompt.
2877   loaded_.clear();
2878   ExtensionInstallPrompt::g_auto_confirm_for_tests =
2879       ExtensionInstallPrompt::CANCEL;
2880
2881   service()->ReloadExtension(good1);
2882   base::RunLoop().RunUntilIdle();
2883   EXPECT_EQ(1u, loaded_.size());
2884   EXPECT_EQ(2u, registry()->enabled_extensions().size());
2885   EXPECT_EQ(0u, registry()->disabled_extensions().size());
2886 }
2887 #endif  // !defined(OS_POSIX) || defined(OS_MACOSX)
2888
2889 namespace {
2890
2891 bool IsExtension(const Extension* extension) {
2892   return extension->GetType() == Manifest::TYPE_EXTENSION;
2893 }
2894
2895 #if defined(ENABLE_BLACKLIST_TESTS)
2896 std::set<std::string> StringSet(const std::string& s) {
2897   std::set<std::string> set;
2898   set.insert(s);
2899   return set;
2900 }
2901 std::set<std::string> StringSet(const std::string& s1, const std::string& s2) {
2902   std::set<std::string> set = StringSet(s1);
2903   set.insert(s2);
2904   return set;
2905 }
2906 #endif  // defined(ENABLE_BLACKLIST_TESTS)
2907
2908 }  // namespace
2909
2910 // Test adding a pending extension.
2911 TEST_F(ExtensionServiceTest, AddPendingExtensionFromSync) {
2912   InitializeEmptyExtensionService();
2913
2914   const std::string kFakeId(all_zero);
2915   const GURL kFakeUpdateURL("http:://fake.update/url");
2916   const bool kFakeInstallSilently(true);
2917   const bool kFakeRemoteInstall(false);
2918   const bool kFakeInstalledByCustodian(false);
2919
2920   EXPECT_TRUE(
2921       service()->pending_extension_manager()->AddFromSync(
2922           kFakeId,
2923           kFakeUpdateURL,
2924           &IsExtension,
2925           kFakeInstallSilently,
2926           kFakeRemoteInstall,
2927           kFakeInstalledByCustodian));
2928
2929   const extensions::PendingExtensionInfo* pending_extension_info;
2930   ASSERT_TRUE((pending_extension_info =
2931                    service()->pending_extension_manager()->GetById(kFakeId)));
2932   EXPECT_EQ(kFakeUpdateURL, pending_extension_info->update_url());
2933   EXPECT_EQ(&IsExtension, pending_extension_info->should_allow_install_);
2934   EXPECT_EQ(kFakeInstallSilently, pending_extension_info->install_silently());
2935   // Use
2936   // EXPECT_TRUE(kFakeRemoteInstall == pending_extension_info->remote_install())
2937   // instead of
2938   // EXPECT_EQ(kFakeRemoteInstall, pending_extension_info->remote_install())
2939   // as gcc 4.7 issues the following warning on EXPECT_EQ(false, x), which is
2940   // turned into an error with -Werror=conversion-null:
2941   //   converting 'false' to pointer type for argument 1 of
2942   //   'char testing::internal::IsNullLiteralHelper(testing::internal::Secret*)'
2943   // https://code.google.com/p/googletest/issues/detail?id=458
2944   EXPECT_TRUE(kFakeRemoteInstall == pending_extension_info->remote_install());
2945 }
2946
2947 namespace {
2948 const char kGoodId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
2949 const char kGoodUpdateURL[] = "http://good.update/url";
2950 const bool kGoodIsFromSync = true;
2951 const bool kGoodInstallSilently = true;
2952 const bool kGoodRemoteInstall = false;
2953 const bool kGoodInstalledByCustodian = false;
2954 }  // namespace
2955
2956 // Test updating a pending extension.
2957 TEST_F(ExtensionServiceTest, UpdatePendingExtension) {
2958   InitializeEmptyExtensionService();
2959   EXPECT_TRUE(
2960       service()->pending_extension_manager()->AddFromSync(
2961           kGoodId,
2962           GURL(kGoodUpdateURL),
2963           &IsExtension,
2964           kGoodInstallSilently,
2965           kGoodRemoteInstall,
2966           kGoodInstalledByCustodian));
2967   EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
2968
2969   base::FilePath path = data_dir().AppendASCII("good.crx");
2970   UpdateExtension(kGoodId, path, ENABLED);
2971
2972   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
2973
2974   const Extension* extension = service()->GetExtensionById(kGoodId, true);
2975   ASSERT_TRUE(extension);
2976 }
2977
2978 namespace {
2979
2980 bool IsTheme(const Extension* extension) {
2981   return extension->is_theme();
2982 }
2983
2984 }  // namespace
2985
2986 // Test updating a pending theme.
2987 // Disabled due to ASAN failure. http://crbug.com/108320
2988 TEST_F(ExtensionServiceTest, DISABLED_UpdatePendingTheme) {
2989   InitializeEmptyExtensionService();
2990   EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
2991       theme_crx, GURL(), &IsTheme, false, false, false));
2992   EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
2993
2994   base::FilePath path = data_dir().AppendASCII("theme.crx");
2995   UpdateExtension(theme_crx, path, ENABLED);
2996
2997   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
2998
2999   const Extension* extension = service()->GetExtensionById(theme_crx, true);
3000   ASSERT_TRUE(extension);
3001
3002   EXPECT_FALSE(
3003       ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
3004   EXPECT_TRUE(service()->IsExtensionEnabled(theme_crx));
3005 }
3006
3007 #if defined(OS_CHROMEOS)
3008 // Always fails on ChromeOS: http://crbug.com/79737
3009 #define MAYBE_UpdatePendingExternalCrx DISABLED_UpdatePendingExternalCrx
3010 #else
3011 #define MAYBE_UpdatePendingExternalCrx UpdatePendingExternalCrx
3012 #endif
3013 // Test updating a pending CRX as if the source is an external extension
3014 // with an update URL.  In this case we don't know if the CRX is a theme
3015 // or not.
3016 TEST_F(ExtensionServiceTest, MAYBE_UpdatePendingExternalCrx) {
3017   InitializeEmptyExtensionService();
3018   EXPECT_TRUE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
3019       theme_crx,
3020       std::string(),
3021       GURL(),
3022       Manifest::EXTERNAL_PREF_DOWNLOAD,
3023       Extension::NO_FLAGS,
3024       false));
3025
3026   EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
3027
3028   base::FilePath path = data_dir().AppendASCII("theme.crx");
3029   UpdateExtension(theme_crx, path, ENABLED);
3030
3031   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
3032
3033   const Extension* extension = service()->GetExtensionById(theme_crx, true);
3034   ASSERT_TRUE(extension);
3035
3036   EXPECT_FALSE(
3037       ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
3038   EXPECT_TRUE(service()->IsExtensionEnabled(extension->id()));
3039   EXPECT_FALSE(
3040       extensions::util::IsIncognitoEnabled(extension->id(), profile()));
3041 }
3042
3043 // Test updating a pending CRX as if the source is an external extension
3044 // with an update URL.  The external update should overwrite a sync update,
3045 // but a sync update should not overwrite a non-sync update.
3046 TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
3047   InitializeEmptyExtensionService();
3048
3049   // Add a crx to be installed from the update mechanism.
3050   EXPECT_TRUE(
3051       service()->pending_extension_manager()->AddFromSync(
3052           kGoodId,
3053           GURL(kGoodUpdateURL),
3054           &IsExtension,
3055           kGoodInstallSilently,
3056           kGoodRemoteInstall,
3057           kGoodInstalledByCustodian));
3058
3059   // Check that there is a pending crx, with is_from_sync set to true.
3060   const extensions::PendingExtensionInfo* pending_extension_info;
3061   ASSERT_TRUE((pending_extension_info =
3062                    service()->pending_extension_manager()->GetById(kGoodId)));
3063   EXPECT_TRUE(pending_extension_info->is_from_sync());
3064
3065   // Add a crx to be updated, with the same ID, from a non-sync source.
3066   EXPECT_TRUE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
3067       kGoodId,
3068       std::string(),
3069       GURL(kGoodUpdateURL),
3070       Manifest::EXTERNAL_PREF_DOWNLOAD,
3071       Extension::NO_FLAGS,
3072       false));
3073
3074   // Check that there is a pending crx, with is_from_sync set to false.
3075   ASSERT_TRUE((pending_extension_info =
3076                    service()->pending_extension_manager()->GetById(kGoodId)));
3077   EXPECT_FALSE(pending_extension_info->is_from_sync());
3078   EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
3079             pending_extension_info->install_source());
3080
3081   // Add a crx to be installed from the update mechanism.
3082   EXPECT_FALSE(
3083       service()->pending_extension_manager()->AddFromSync(
3084           kGoodId,
3085           GURL(kGoodUpdateURL),
3086           &IsExtension,
3087           kGoodInstallSilently,
3088           kGoodRemoteInstall,
3089           kGoodInstalledByCustodian));
3090
3091   // Check that the external, non-sync update was not overridden.
3092   ASSERT_TRUE((pending_extension_info =
3093                    service()->pending_extension_manager()->GetById(kGoodId)));
3094   EXPECT_FALSE(pending_extension_info->is_from_sync());
3095   EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
3096             pending_extension_info->install_source());
3097 }
3098
3099 // Updating a theme should fail if the updater is explicitly told that
3100 // the CRX is not a theme.
3101 TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
3102   InitializeEmptyExtensionService();
3103   EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
3104       theme_crx, GURL(), &IsExtension, true, false, false));
3105
3106   EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
3107
3108   base::FilePath path = data_dir().AppendASCII("theme.crx");
3109   UpdateExtension(theme_crx, path, FAILED_SILENTLY);
3110
3111   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
3112
3113   const Extension* extension = service()->GetExtensionById(theme_crx, true);
3114   ASSERT_FALSE(extension);
3115 }
3116
3117 // TODO(akalin): Test updating a pending extension non-silently once
3118 // we can mock out ExtensionInstallUI and inject our version into
3119 // UpdateExtension().
3120
3121 // Test updating a pending extension which fails the should-install test.
3122 TEST_F(ExtensionServiceTest, UpdatePendingExtensionFailedShouldInstallTest) {
3123   InitializeEmptyExtensionService();
3124   // Add pending extension with a flipped is_theme.
3125   EXPECT_TRUE(
3126       service()->pending_extension_manager()->AddFromSync(
3127           kGoodId,
3128           GURL(kGoodUpdateURL),
3129           &IsTheme,
3130           kGoodInstallSilently,
3131           kGoodRemoteInstall,
3132           kGoodInstalledByCustodian));
3133   EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
3134
3135   base::FilePath path = data_dir().AppendASCII("good.crx");
3136   UpdateExtension(kGoodId, path, UPDATED);
3137
3138   // TODO(akalin): Figure out how to check that the extensions
3139   // directory is cleaned up properly in OnExtensionInstalled().
3140
3141   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
3142 }
3143
3144 // TODO(akalin): Figure out how to test that installs of pending
3145 // unsyncable extensions are blocked.
3146
3147 // Test updating a pending extension for one that is not pending.
3148 TEST_F(ExtensionServiceTest, UpdatePendingExtensionNotPending) {
3149   InitializeEmptyExtensionService();
3150
3151   base::FilePath path = data_dir().AppendASCII("good.crx");
3152   UpdateExtension(kGoodId, path, UPDATED);
3153
3154   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
3155 }
3156
3157 // Test updating a pending extension for one that is already
3158 // installed.
3159 TEST_F(ExtensionServiceTest, UpdatePendingExtensionAlreadyInstalled) {
3160   InitializeEmptyExtensionService();
3161
3162   base::FilePath path = data_dir().AppendASCII("good.crx");
3163   const Extension* good = InstallCRX(path, INSTALL_NEW);
3164   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3165
3166   EXPECT_FALSE(good->is_theme());
3167
3168   // Use AddExtensionImpl() as AddFrom*() would balk.
3169   service()->pending_extension_manager()->AddExtensionImpl(
3170       good->id(),
3171       std::string(),
3172       extensions::ManifestURL::GetUpdateURL(good),
3173       Version(),
3174       &IsExtension,
3175       kGoodIsFromSync,
3176       kGoodInstallSilently,
3177       Manifest::INTERNAL,
3178       Extension::NO_FLAGS,
3179       false,
3180       kGoodRemoteInstall);
3181   UpdateExtension(good->id(), path, ENABLED);
3182
3183   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
3184 }
3185
3186 #if defined(ENABLE_BLACKLIST_TESTS)
3187 // Tests blacklisting then unblacklisting extensions after the service has been
3188 // initialized.
3189 TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
3190   extensions::TestBlacklist test_blacklist;
3191   // A profile with 3 extensions installed: good0, good1, and good2.
3192   InitializeGoodInstalledExtensionService();
3193   test_blacklist.Attach(service()->blacklist_);
3194   service()->Init();
3195
3196   const extensions::ExtensionSet& enabled_extensions =
3197       registry()->enabled_extensions();
3198   const extensions::ExtensionSet& blacklisted_extensions =
3199       registry()->blacklisted_extensions();
3200
3201   EXPECT_TRUE(enabled_extensions.Contains(good0) &&
3202               !blacklisted_extensions.Contains(good0));
3203   EXPECT_TRUE(enabled_extensions.Contains(good1) &&
3204               !blacklisted_extensions.Contains(good1));
3205   EXPECT_TRUE(enabled_extensions.Contains(good2) &&
3206               !blacklisted_extensions.Contains(good2));
3207
3208   EXPECT_FALSE(IsPrefExist(good0, "blacklist"));
3209   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
3210   EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
3211   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
3212
3213   // Blacklist good0 and good1 (and an invalid extension ID).
3214   test_blacklist.SetBlacklistState(
3215       good0, extensions::BLACKLISTED_MALWARE, true);
3216   test_blacklist.SetBlacklistState(
3217       good1, extensions::BLACKLISTED_MALWARE, true);
3218   test_blacklist.SetBlacklistState(
3219       "invalid_id", extensions::BLACKLISTED_MALWARE, true);
3220   base::RunLoop().RunUntilIdle();
3221
3222   EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
3223               blacklisted_extensions.Contains(good0));
3224   EXPECT_TRUE(!enabled_extensions.Contains(good1) &&
3225               blacklisted_extensions.Contains(good1));
3226   EXPECT_TRUE(enabled_extensions.Contains(good2) &&
3227               !blacklisted_extensions.Contains(good2));
3228
3229   EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
3230   EXPECT_TRUE(ValidateBooleanPref(good1, "blacklist", true));
3231   EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
3232   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
3233
3234   // Un-blacklist good1 and blacklist good2.
3235   test_blacklist.Clear(false);
3236   test_blacklist.SetBlacklistState(
3237       good0, extensions::BLACKLISTED_MALWARE, true);
3238   test_blacklist.SetBlacklistState(
3239       good2, extensions::BLACKLISTED_MALWARE, true);
3240   test_blacklist.SetBlacklistState(
3241       "invalid_id", extensions::BLACKLISTED_MALWARE, true);
3242   base::RunLoop().RunUntilIdle();
3243
3244   EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
3245               blacklisted_extensions.Contains(good0));
3246   EXPECT_TRUE(enabled_extensions.Contains(good1) &&
3247               !blacklisted_extensions.Contains(good1));
3248   EXPECT_TRUE(!enabled_extensions.Contains(good2) &&
3249               blacklisted_extensions.Contains(good2));
3250
3251   EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
3252   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
3253   EXPECT_TRUE(ValidateBooleanPref(good2, "blacklist", true));
3254   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
3255 }
3256 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3257
3258 #if defined(ENABLE_BLACKLIST_TESTS)
3259 // Tests trying to install a blacklisted extension.
3260 TEST_F(ExtensionServiceTest, BlacklistedExtensionWillNotInstall) {
3261   scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
3262       new FakeSafeBrowsingDatabaseManager(true));
3263   Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
3264
3265   InitializeEmptyExtensionService();
3266   service()->Init();
3267
3268   // After blacklisting good_crx, we cannot install it.
3269   blacklist_db->SetUnsafe(good_crx).NotifyUpdate();
3270   base::RunLoop().RunUntilIdle();
3271
3272   base::FilePath path = data_dir().AppendASCII("good.crx");
3273   // HACK: specify WAS_INSTALLED_BY_DEFAULT so that test machinery doesn't
3274   // decide to install this silently. Somebody should fix these tests, all
3275   // 6,000 lines of them. Hah!
3276   InstallCRX(path, INSTALL_FAILED, Extension::WAS_INSTALLED_BY_DEFAULT);
3277   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3278 }
3279 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3280
3281 #if defined(ENABLE_BLACKLIST_TESTS)
3282 // Unload blacklisted extension on policy change.
3283 TEST_F(ExtensionServiceTest, UnloadBlacklistedExtensionPolicy) {
3284   extensions::TestBlacklist test_blacklist;
3285
3286   // A profile with no extensions installed.
3287   InitializeEmptyExtensionServiceWithTestingPrefs();
3288   test_blacklist.Attach(service()->blacklist_);
3289
3290   base::FilePath path = data_dir().AppendASCII("good.crx");
3291
3292   const Extension* good = InstallCRX(path, INSTALL_NEW);
3293   EXPECT_EQ(good_crx, good->id());
3294   UpdateExtension(good_crx, path, FAILED_SILENTLY);
3295   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3296
3297   {
3298     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3299     pref.SetIndividualExtensionInstallationAllowed(good_crx, true);
3300   }
3301
3302   test_blacklist.SetBlacklistState(
3303       good_crx, extensions::BLACKLISTED_MALWARE, true);
3304   base::RunLoop().RunUntilIdle();
3305
3306   // The good_crx is blacklisted and the whitelist doesn't negate it.
3307   ASSERT_TRUE(ValidateBooleanPref(good_crx, "blacklist", true));
3308   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3309 }
3310 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3311
3312 #if defined(ENABLE_BLACKLIST_TESTS)
3313 // Tests that a blacklisted extension is eventually unloaded on startup, if it
3314 // wasn't already.
3315 TEST_F(ExtensionServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
3316   extensions::TestBlacklist test_blacklist;
3317
3318   // A profile with 3 extensions installed: good0, good1, and good2.
3319   InitializeGoodInstalledExtensionService();
3320   test_blacklist.Attach(service()->blacklist_);
3321
3322   // Blacklist good1 before the service initializes.
3323   test_blacklist.SetBlacklistState(
3324       good1, extensions::BLACKLISTED_MALWARE, false);
3325
3326   // Load extensions.
3327   service()->Init();
3328   ASSERT_EQ(3u, loaded_.size());  // hasn't had time to blacklist yet
3329
3330   base::RunLoop().RunUntilIdle();
3331
3332   ASSERT_EQ(1u, registry()->blacklisted_extensions().size());
3333   ASSERT_EQ(2u, registry()->enabled_extensions().size());
3334
3335   ASSERT_TRUE(registry()->enabled_extensions().Contains(good0));
3336   ASSERT_TRUE(registry()->blacklisted_extensions().Contains(good1));
3337   ASSERT_TRUE(registry()->enabled_extensions().Contains(good2));
3338 }
3339 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3340
3341 #if defined(ENABLE_BLACKLIST_TESTS)
3342 // Tests extensions blacklisted in prefs on startup; one still blacklisted by
3343 // safe browsing, the other not. The not-blacklisted one should recover.
3344 TEST_F(ExtensionServiceTest, BlacklistedInPrefsFromStartup) {
3345   extensions::TestBlacklist test_blacklist;
3346
3347   InitializeGoodInstalledExtensionService();
3348   test_blacklist.Attach(service()->blacklist_);
3349   ExtensionPrefs::Get(profile())->SetExtensionBlacklisted(good0, true);
3350   ExtensionPrefs::Get(profile())->SetExtensionBlacklisted(good1, true);
3351
3352   test_blacklist.SetBlacklistState(
3353       good1, extensions::BLACKLISTED_MALWARE, false);
3354
3355   // Extension service hasn't loaded yet, but IsExtensionEnabled reads out of
3356   // prefs. Ensure it takes into account the blacklist state (crbug.com/373842).
3357   EXPECT_FALSE(service()->IsExtensionEnabled(good0));
3358   EXPECT_FALSE(service()->IsExtensionEnabled(good1));
3359   EXPECT_TRUE(service()->IsExtensionEnabled(good2));
3360
3361   service()->Init();
3362
3363   EXPECT_EQ(2u, registry()->blacklisted_extensions().size());
3364   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3365
3366   EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good0));
3367   EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good1));
3368   EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
3369
3370   // Give time for the blacklist to update.
3371   base::RunLoop().RunUntilIdle();
3372
3373   EXPECT_EQ(1u, registry()->blacklisted_extensions().size());
3374   EXPECT_EQ(2u, registry()->enabled_extensions().size());
3375
3376   EXPECT_TRUE(registry()->enabled_extensions().Contains(good0));
3377   EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good1));
3378   EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
3379 }
3380 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3381
3382 #if defined(ENABLE_BLACKLIST_TESTS)
3383 // Extension is added to blacklist with BLACKLISTED_POTENTIALLY_UNWANTED state
3384 // after it is installed. It is then successfully re-enabled by the user.
3385 TEST_F(ExtensionServiceTest, GreylistedExtensionDisabled) {
3386   extensions::TestBlacklist test_blacklist;
3387   // A profile with 3 extensions installed: good0, good1, and good2.
3388   InitializeGoodInstalledExtensionService();
3389   test_blacklist.Attach(service()->blacklist_);
3390   service()->Init();
3391
3392   const extensions::ExtensionSet& enabled_extensions =
3393       registry()->enabled_extensions();
3394   const extensions::ExtensionSet& disabled_extensions =
3395       registry()->disabled_extensions();
3396
3397   EXPECT_TRUE(enabled_extensions.Contains(good0));
3398   EXPECT_TRUE(enabled_extensions.Contains(good1));
3399   EXPECT_TRUE(enabled_extensions.Contains(good2));
3400
3401   // Blacklist good0 and good1 (and an invalid extension ID).
3402   test_blacklist.SetBlacklistState(
3403       good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
3404   test_blacklist.SetBlacklistState(
3405       good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
3406   test_blacklist.SetBlacklistState(
3407       "invalid_id", extensions::BLACKLISTED_MALWARE, true);
3408   base::RunLoop().RunUntilIdle();
3409
3410   EXPECT_FALSE(enabled_extensions.Contains(good0));
3411   EXPECT_TRUE(disabled_extensions.Contains(good0));
3412   EXPECT_FALSE(enabled_extensions.Contains(good1));
3413   EXPECT_TRUE(disabled_extensions.Contains(good1));
3414   EXPECT_TRUE(enabled_extensions.Contains(good2));
3415   EXPECT_FALSE(disabled_extensions.Contains(good2));
3416
3417   ValidateIntegerPref(
3418       good0, "blacklist_state", extensions::BLACKLISTED_CWS_POLICY_VIOLATION);
3419   ValidateIntegerPref(
3420       good1, "blacklist_state", extensions::BLACKLISTED_POTENTIALLY_UNWANTED);
3421
3422   // Now user enables good0.
3423   service()->EnableExtension(good0);
3424
3425   EXPECT_TRUE(enabled_extensions.Contains(good0));
3426   EXPECT_FALSE(disabled_extensions.Contains(good0));
3427   EXPECT_FALSE(enabled_extensions.Contains(good1));
3428   EXPECT_TRUE(disabled_extensions.Contains(good1));
3429
3430   // Remove extensions from blacklist.
3431   test_blacklist.SetBlacklistState(
3432       good0, extensions::NOT_BLACKLISTED, true);
3433   test_blacklist.SetBlacklistState(
3434       good1, extensions::NOT_BLACKLISTED, true);
3435   base::RunLoop().RunUntilIdle();
3436
3437   // All extensions are enabled.
3438   EXPECT_TRUE(enabled_extensions.Contains(good0));
3439   EXPECT_FALSE(disabled_extensions.Contains(good0));
3440   EXPECT_TRUE(enabled_extensions.Contains(good1));
3441   EXPECT_FALSE(disabled_extensions.Contains(good1));
3442   EXPECT_TRUE(enabled_extensions.Contains(good2));
3443   EXPECT_FALSE(disabled_extensions.Contains(good2));
3444 }
3445 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3446
3447 #if defined(ENABLE_BLACKLIST_TESTS)
3448 // When extension is removed from greylist, do not re-enable it if it is
3449 // disabled by user.
3450 TEST_F(ExtensionServiceTest, GreylistDontEnableManuallyDisabled) {
3451   extensions::TestBlacklist test_blacklist;
3452   // A profile with 3 extensions installed: good0, good1, and good2.
3453   InitializeGoodInstalledExtensionService();
3454   test_blacklist.Attach(service()->blacklist_);
3455   service()->Init();
3456
3457   const extensions::ExtensionSet& enabled_extensions =
3458       registry()->enabled_extensions();
3459   const extensions::ExtensionSet& disabled_extensions =
3460       registry()->disabled_extensions();
3461
3462   // Manually disable.
3463   service()->DisableExtension(good0,
3464                               extensions::Extension::DISABLE_USER_ACTION);
3465
3466   test_blacklist.SetBlacklistState(
3467       good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
3468   test_blacklist.SetBlacklistState(
3469       good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
3470   test_blacklist.SetBlacklistState(
3471       good2, extensions::BLACKLISTED_SECURITY_VULNERABILITY, true);
3472   base::RunLoop().RunUntilIdle();
3473
3474   // All extensions disabled.
3475   EXPECT_FALSE(enabled_extensions.Contains(good0));
3476   EXPECT_TRUE(disabled_extensions.Contains(good0));
3477   EXPECT_FALSE(enabled_extensions.Contains(good1));
3478   EXPECT_TRUE(disabled_extensions.Contains(good1));
3479   EXPECT_FALSE(enabled_extensions.Contains(good2));
3480   EXPECT_TRUE(disabled_extensions.Contains(good2));
3481
3482   // Greylisted extension can be enabled.
3483   service()->EnableExtension(good1);
3484   EXPECT_TRUE(enabled_extensions.Contains(good1));
3485   EXPECT_FALSE(disabled_extensions.Contains(good1));
3486
3487   // good1 is now manually disabled.
3488   service()->DisableExtension(good1,
3489                               extensions::Extension::DISABLE_USER_ACTION);
3490   EXPECT_FALSE(enabled_extensions.Contains(good1));
3491   EXPECT_TRUE(disabled_extensions.Contains(good1));
3492
3493   // Remove extensions from blacklist.
3494   test_blacklist.SetBlacklistState(
3495       good0, extensions::NOT_BLACKLISTED, true);
3496   test_blacklist.SetBlacklistState(
3497       good1, extensions::NOT_BLACKLISTED, true);
3498   test_blacklist.SetBlacklistState(
3499       good2, extensions::NOT_BLACKLISTED, true);
3500   base::RunLoop().RunUntilIdle();
3501
3502   // good0 and good1 remain disabled.
3503   EXPECT_FALSE(enabled_extensions.Contains(good0));
3504   EXPECT_TRUE(disabled_extensions.Contains(good0));
3505   EXPECT_FALSE(enabled_extensions.Contains(good1));
3506   EXPECT_TRUE(disabled_extensions.Contains(good1));
3507   EXPECT_TRUE(enabled_extensions.Contains(good2));
3508   EXPECT_FALSE(disabled_extensions.Contains(good2));
3509 }
3510 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3511
3512 #if defined(ENABLE_BLACKLIST_TESTS)
3513 // Blacklisted extension with unknown state are not enabled/disabled.
3514 TEST_F(ExtensionServiceTest, GreylistUnknownDontChange) {
3515   extensions::TestBlacklist test_blacklist;
3516   // A profile with 3 extensions installed: good0, good1, and good2.
3517   InitializeGoodInstalledExtensionService();
3518   test_blacklist.Attach(service()->blacklist_);
3519   service()->Init();
3520
3521   const extensions::ExtensionSet& enabled_extensions =
3522       registry()->enabled_extensions();
3523   const extensions::ExtensionSet& disabled_extensions =
3524       registry()->disabled_extensions();
3525
3526   test_blacklist.SetBlacklistState(
3527       good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
3528   test_blacklist.SetBlacklistState(
3529       good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
3530   base::RunLoop().RunUntilIdle();
3531
3532   EXPECT_FALSE(enabled_extensions.Contains(good0));
3533   EXPECT_TRUE(disabled_extensions.Contains(good0));
3534   EXPECT_FALSE(enabled_extensions.Contains(good1));
3535   EXPECT_TRUE(disabled_extensions.Contains(good1));
3536   EXPECT_TRUE(enabled_extensions.Contains(good2));
3537   EXPECT_FALSE(disabled_extensions.Contains(good2));
3538
3539   test_blacklist.SetBlacklistState(
3540       good0, extensions::NOT_BLACKLISTED, true);
3541   test_blacklist.SetBlacklistState(
3542       good1, extensions::BLACKLISTED_UNKNOWN, true);
3543   test_blacklist.SetBlacklistState(
3544       good2, extensions::BLACKLISTED_UNKNOWN, true);
3545   base::RunLoop().RunUntilIdle();
3546
3547   // good0 re-enabled, other remain as they were.
3548   EXPECT_TRUE(enabled_extensions.Contains(good0));
3549   EXPECT_FALSE(disabled_extensions.Contains(good0));
3550   EXPECT_FALSE(enabled_extensions.Contains(good1));
3551   EXPECT_TRUE(disabled_extensions.Contains(good1));
3552   EXPECT_TRUE(enabled_extensions.Contains(good2));
3553   EXPECT_FALSE(disabled_extensions.Contains(good2));
3554 }
3555
3556 // Tests that blacklisted extensions cannot be reloaded, both those loaded
3557 // before and after extension service startup.
3558 TEST_F(ExtensionServiceTest, ReloadBlacklistedExtension) {
3559   extensions::TestBlacklist test_blacklist;
3560
3561   InitializeGoodInstalledExtensionService();
3562   test_blacklist.Attach(service()->blacklist_);
3563
3564   test_blacklist.SetBlacklistState(
3565       good1, extensions::BLACKLISTED_MALWARE, false);
3566   service()->Init();
3567   test_blacklist.SetBlacklistState(
3568       good2, extensions::BLACKLISTED_MALWARE, false);
3569   base::RunLoop().RunUntilIdle();
3570
3571   EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
3572   EXPECT_EQ(StringSet(good1, good2),
3573             registry()->blacklisted_extensions().GetIDs());
3574
3575   service()->ReloadExtension(good1);
3576   service()->ReloadExtension(good2);
3577   base::RunLoop().RunUntilIdle();
3578
3579   EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
3580   EXPECT_EQ(StringSet(good1, good2),
3581             registry()->blacklisted_extensions().GetIDs());
3582 }
3583
3584 #endif  // defined(ENABLE_BLACKLIST_TESTS)
3585
3586 // Will not install extension blacklisted by policy.
3587 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
3588   InitializeEmptyExtensionServiceWithTestingPrefs();
3589
3590   // Blacklist everything.
3591   {
3592     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3593     pref.SetBlacklistedByDefault(true);
3594   }
3595
3596   // Blacklist prevents us from installing good_crx.
3597   base::FilePath path = data_dir().AppendASCII("good.crx");
3598   InstallCRX(path, INSTALL_FAILED);
3599   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3600
3601   // Now whitelist this particular extension.
3602   {
3603     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3604     pref.SetIndividualExtensionInstallationAllowed(good_crx, true);
3605   }
3606
3607   // Ensure we can now install good_crx.
3608   InstallCRX(path, INSTALL_NEW);
3609   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3610 }
3611
3612 // Extension blacklisted by policy get unloaded after installing.
3613 TEST_F(ExtensionServiceTest, BlacklistedByPolicyRemovedIfRunning) {
3614   InitializeEmptyExtensionServiceWithTestingPrefs();
3615
3616   // Install good_crx.
3617   base::FilePath path = data_dir().AppendASCII("good.crx");
3618   InstallCRX(path, INSTALL_NEW);
3619   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3620
3621   {
3622     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3623     // Blacklist this extension.
3624     pref.SetIndividualExtensionInstallationAllowed(good_crx, false);
3625   }
3626
3627   // Extension should not be running now.
3628   base::RunLoop().RunUntilIdle();
3629   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3630 }
3631
3632 // Tests that component extensions are not blacklisted by policy.
3633 TEST_F(ExtensionServiceTest, ComponentExtensionWhitelisted) {
3634   InitializeEmptyExtensionServiceWithTestingPrefs();
3635
3636   // Blacklist everything.
3637   {
3638     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3639     pref.SetBlacklistedByDefault(true);
3640   }
3641
3642   // Install a component extension.
3643   base::FilePath path = data_dir()
3644                             .AppendASCII("good")
3645                             .AppendASCII("Extensions")
3646                             .AppendASCII(good0)
3647                             .AppendASCII("1.0.0.0");
3648   std::string manifest;
3649   ASSERT_TRUE(base::ReadFileToString(
3650       path.Append(extensions::kManifestFilename), &manifest));
3651   service()->component_loader()->Add(manifest, path);
3652   service()->Init();
3653
3654   // Extension should be installed despite blacklist.
3655   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3656   EXPECT_TRUE(service()->GetExtensionById(good0, false));
3657
3658   // Poke external providers and make sure the extension is still present.
3659   service()->CheckForExternalUpdates();
3660   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3661   EXPECT_TRUE(service()->GetExtensionById(good0, false));
3662
3663   // Extension should not be uninstalled on blacklist changes.
3664   {
3665     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3666     pref.SetIndividualExtensionInstallationAllowed(good0, false);
3667   }
3668   base::RunLoop().RunUntilIdle();
3669   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3670   EXPECT_TRUE(service()->GetExtensionById(good0, false));
3671 }
3672
3673 // Tests that policy-installed extensions are not blacklisted by policy.
3674 TEST_F(ExtensionServiceTest, PolicyInstalledExtensionsWhitelisted) {
3675   InitializeEmptyExtensionServiceWithTestingPrefs();
3676
3677   {
3678     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3679     // Blacklist everything.
3680     pref.SetBlacklistedByDefault(true);
3681     // Mark good.crx for force-installation.
3682     pref.SetIndividualExtensionAutoInstalled(
3683         good_crx, "http://example.com/update_url", true);
3684   }
3685
3686   // Have policy force-install an extension.
3687   MockExtensionProvider* provider =
3688       new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
3689   AddMockExternalProvider(provider);
3690   provider->UpdateOrAddExtension(
3691       good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
3692
3693   // Reloading extensions should find our externally registered extension
3694   // and install it.
3695   content::WindowedNotificationObserver observer(
3696       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
3697       content::NotificationService::AllSources());
3698   service()->CheckForExternalUpdates();
3699   observer.Wait();
3700
3701   // Extension should be installed despite blacklist.
3702   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3703   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3704
3705   // Blacklist update should not uninstall the extension.
3706   {
3707     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
3708     pref.SetIndividualExtensionInstallationAllowed(good0, false);
3709   }
3710   base::RunLoop().RunUntilIdle();
3711   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3712   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3713 }
3714
3715 // Tests that extensions cannot be installed if the policy provider prohibits
3716 // it. This functionality is implemented in CrxInstaller::ConfirmInstall().
3717 TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsInstall) {
3718   InitializeEmptyExtensionService();
3719
3720   GetManagementPolicy()->UnregisterAllProviders();
3721   extensions::TestManagementPolicyProvider provider_(
3722       extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
3723   GetManagementPolicy()->RegisterProvider(&provider_);
3724
3725   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_FAILED);
3726   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3727 }
3728
3729 // Tests that extensions cannot be loaded from prefs if the policy provider
3730 // prohibits it. This functionality is implemented in InstalledLoader::Load().
3731 TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsLoadFromPrefs) {
3732   InitializeEmptyExtensionService();
3733
3734   // Create a fake extension to be loaded as though it were read from prefs.
3735   base::FilePath path =
3736       data_dir().AppendASCII("management").AppendASCII("simple_extension");
3737   base::DictionaryValue manifest;
3738   manifest.SetString(keys::kName, "simple_extension");
3739   manifest.SetString(keys::kVersion, "1");
3740   // UNPACKED is for extensions loaded from a directory. We use it here, even
3741   // though we're testing loading from prefs, so that we don't need to provide
3742   // an extension key.
3743   extensions::ExtensionInfo extension_info(
3744       &manifest, std::string(), path, Manifest::UNPACKED);
3745
3746   // Ensure we can load it with no management policy in place.
3747   GetManagementPolicy()->UnregisterAllProviders();
3748   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3749   extensions::InstalledLoader(service()).Load(extension_info, false);
3750   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3751
3752   const Extension* extension =
3753       (registry()->enabled_extensions().begin())->get();
3754   EXPECT_TRUE(
3755       service()->UninstallExtension(extension->id(),
3756                                     extensions::UNINSTALL_REASON_FOR_TESTING,
3757                                     base::Bind(&base::DoNothing),
3758                                     NULL));
3759   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3760
3761   // Ensure we cannot load it if management policy prohibits installation.
3762   extensions::TestManagementPolicyProvider provider_(
3763       extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
3764   GetManagementPolicy()->RegisterProvider(&provider_);
3765
3766   extensions::InstalledLoader(service()).Load(extension_info, false);
3767   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3768 }
3769
3770 // Tests disabling an extension when prohibited by the ManagementPolicy.
3771 TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsDisable) {
3772   InitializeEmptyExtensionService();
3773
3774   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3775   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3776   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3777
3778   GetManagementPolicy()->UnregisterAllProviders();
3779   extensions::TestManagementPolicyProvider provider(
3780       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
3781   GetManagementPolicy()->RegisterProvider(&provider);
3782
3783   // Attempt to disable it.
3784   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
3785
3786   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3787   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3788   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3789 }
3790
3791 // Tests uninstalling an extension when prohibited by the ManagementPolicy.
3792 TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsUninstall) {
3793   InitializeEmptyExtensionService();
3794
3795   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3796   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3797   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3798
3799   GetManagementPolicy()->UnregisterAllProviders();
3800   extensions::TestManagementPolicyProvider provider(
3801       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
3802   GetManagementPolicy()->RegisterProvider(&provider);
3803
3804   // Attempt to uninstall it.
3805   EXPECT_FALSE(
3806       service()->UninstallExtension(good_crx,
3807                                     extensions::UNINSTALL_REASON_FOR_TESTING,
3808                                     base::Bind(&base::DoNothing),
3809                                     NULL));
3810
3811   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3812   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3813 }
3814
3815 // Tests that previously installed extensions that are now prohibited from
3816 // being installed are removed.
3817 TEST_F(ExtensionServiceTest, ManagementPolicyUnloadsAllProhibited) {
3818   InitializeEmptyExtensionService();
3819
3820   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3821   InstallCRX(data_dir().AppendASCII("page_action.crx"), INSTALL_NEW);
3822   EXPECT_EQ(2u, registry()->enabled_extensions().size());
3823   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3824
3825   GetManagementPolicy()->UnregisterAllProviders();
3826   extensions::TestManagementPolicyProvider provider(
3827       extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
3828   GetManagementPolicy()->RegisterProvider(&provider);
3829
3830   // Run the policy check.
3831   service()->CheckManagementPolicy();
3832   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3833   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3834 }
3835
3836 // Tests that previously disabled extensions that are now required to be
3837 // enabled are re-enabled on reinstall.
3838 TEST_F(ExtensionServiceTest, ManagementPolicyRequiresEnable) {
3839   InitializeEmptyExtensionService();
3840
3841   // Install, then disable, an extension.
3842   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3843   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3844   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
3845   EXPECT_EQ(1u, registry()->disabled_extensions().size());
3846
3847   // Register an ExtensionMnagementPolicy that requires the extension to remain
3848   // enabled.
3849   GetManagementPolicy()->UnregisterAllProviders();
3850   extensions::TestManagementPolicyProvider provider(
3851       extensions::TestManagementPolicyProvider::MUST_REMAIN_ENABLED);
3852   GetManagementPolicy()->RegisterProvider(&provider);
3853
3854   // Reinstall the extension.
3855   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_UPDATED);
3856   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3857   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3858 }
3859
3860 // Flaky on windows; http://crbug.com/309833
3861 #if defined(OS_WIN)
3862 #define MAYBE_ExternalExtensionAutoAcknowledgement DISABLED_ExternalExtensionAutoAcknowledgement
3863 #else
3864 #define MAYBE_ExternalExtensionAutoAcknowledgement ExternalExtensionAutoAcknowledgement
3865 #endif
3866 TEST_F(ExtensionServiceTest, MAYBE_ExternalExtensionAutoAcknowledgement) {
3867   InitializeEmptyExtensionService();
3868   service()->set_extensions_enabled(true);
3869
3870   {
3871     // Register and install an external extension.
3872     MockExtensionProvider* provider =
3873         new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
3874     AddMockExternalProvider(provider);
3875     provider->UpdateOrAddExtension(
3876         good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
3877   }
3878   {
3879     // Have policy force-install an extension.
3880     MockExtensionProvider* provider = new MockExtensionProvider(
3881         service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
3882     AddMockExternalProvider(provider);
3883     provider->UpdateOrAddExtension(
3884         page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
3885   }
3886
3887   // Providers are set up. Let them run.
3888   int count = 2;
3889   content::WindowedNotificationObserver observer(
3890       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
3891       base::Bind(&WaitForCountNotificationsCallback, &count));
3892   service()->CheckForExternalUpdates();
3893
3894   observer.Wait();
3895
3896   ASSERT_EQ(2u, registry()->enabled_extensions().size());
3897   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3898   EXPECT_TRUE(service()->GetExtensionById(page_action, false));
3899   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
3900   ASSERT_TRUE(!prefs->IsExternalExtensionAcknowledged(good_crx));
3901   ASSERT_TRUE(prefs->IsExternalExtensionAcknowledged(page_action));
3902 }
3903
3904 #if !defined(OS_CHROMEOS)
3905 // This tests if default apps are installed correctly.
3906 TEST_F(ExtensionServiceTest, DefaultAppsInstall) {
3907   InitializeEmptyExtensionService();
3908   service()->set_extensions_enabled(true);
3909
3910   {
3911     std::string json_data =
3912         "{"
3913         "  \"ldnnhddmnhbkjipkidpdiheffobcpfmf\" : {"
3914         "    \"external_crx\": \"good.crx\","
3915         "    \"external_version\": \"1.0.0.0\","
3916         "    \"is_bookmark_app\": false"
3917         "  }"
3918         "}";
3919     default_apps::Provider* provider = new default_apps::Provider(
3920         profile(),
3921         service(),
3922         new extensions::ExternalTestingLoader(json_data, data_dir()),
3923         Manifest::INTERNAL,
3924         Manifest::INVALID_LOCATION,
3925         Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
3926
3927     AddMockExternalProvider(provider);
3928   }
3929
3930   ASSERT_EQ(0u, registry()->enabled_extensions().size());
3931   content::WindowedNotificationObserver observer(
3932       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
3933       content::NotificationService::AllSources());
3934   service()->CheckForExternalUpdates();
3935   observer.Wait();
3936
3937   ASSERT_EQ(1u, registry()->enabled_extensions().size());
3938   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3939   const Extension* extension = service()->GetExtensionById(good_crx, false);
3940   EXPECT_TRUE(extension->from_webstore());
3941   EXPECT_TRUE(extension->was_installed_by_default());
3942 }
3943 #endif
3944
3945 // Tests disabling extensions
3946 TEST_F(ExtensionServiceTest, DisableExtension) {
3947   InitializeEmptyExtensionService();
3948
3949   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3950   EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
3951   EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
3952
3953   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3954   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3955   EXPECT_EQ(0u, registry()->terminated_extensions().size());
3956   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
3957
3958   // Disable it.
3959   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
3960
3961   EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
3962   EXPECT_FALSE(service()->GetExtensionById(good_crx, false));
3963   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3964   EXPECT_EQ(1u, registry()->disabled_extensions().size());
3965   EXPECT_EQ(0u, registry()->terminated_extensions().size());
3966   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
3967 }
3968
3969 TEST_F(ExtensionServiceTest, TerminateExtension) {
3970   InitializeEmptyExtensionService();
3971
3972   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3973   EXPECT_EQ(1u, registry()->enabled_extensions().size());
3974   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3975   EXPECT_EQ(0u, registry()->terminated_extensions().size());
3976   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
3977
3978   TerminateExtension(good_crx);
3979
3980   EXPECT_EQ(0u, registry()->enabled_extensions().size());
3981   EXPECT_EQ(0u, registry()->disabled_extensions().size());
3982   EXPECT_EQ(1u, registry()->terminated_extensions().size());
3983   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
3984 }
3985
3986 TEST_F(ExtensionServiceTest, DisableTerminatedExtension) {
3987   InitializeEmptyExtensionService();
3988
3989   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
3990   TerminateExtension(good_crx);
3991   EXPECT_TRUE(registry()->GetExtensionById(
3992       good_crx, extensions::ExtensionRegistry::TERMINATED));
3993
3994   // Disable it.
3995   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
3996
3997   EXPECT_FALSE(registry()->GetExtensionById(
3998       good_crx, extensions::ExtensionRegistry::TERMINATED));
3999   EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
4000
4001   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4002   EXPECT_EQ(1u, registry()->disabled_extensions().size());
4003   EXPECT_EQ(0u, registry()->terminated_extensions().size());
4004   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
4005 }
4006
4007 // Tests disabling all extensions (simulating --disable-extensions flag).
4008 TEST_F(ExtensionServiceTest, DisableAllExtensions) {
4009   InitializeEmptyExtensionService();
4010
4011   base::FilePath path = data_dir().AppendASCII("good.crx");
4012   InstallCRX(path, INSTALL_NEW);
4013
4014   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4015   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4016
4017   // Disable extensions.
4018   service()->set_extensions_enabled(false);
4019   service()->ReloadExtensionsForTest();
4020
4021   // There shouldn't be extensions in either list.
4022   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4023   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4024
4025   // This shouldn't do anything when all extensions are disabled.
4026   service()->EnableExtension(good_crx);
4027   service()->ReloadExtensionsForTest();
4028
4029   // There still shouldn't be extensions in either list.
4030   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4031   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4032
4033   // And then re-enable the extensions.
4034   service()->set_extensions_enabled(true);
4035   service()->ReloadExtensionsForTest();
4036
4037   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4038   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4039 }
4040
4041 // Tests reloading extensions.
4042 TEST_F(ExtensionServiceTest, ReloadExtensions) {
4043   InitializeEmptyExtensionService();
4044
4045   // Simple extension that should install without error.
4046   base::FilePath path = data_dir().AppendASCII("good.crx");
4047   InstallCRX(path, INSTALL_NEW,
4048              Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
4049   const char* extension_id = good_crx;
4050   service()->DisableExtension(extension_id, Extension::DISABLE_USER_ACTION);
4051
4052   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4053   EXPECT_EQ(1u, registry()->disabled_extensions().size());
4054
4055   service()->ReloadExtensionsForTest();
4056
4057   // The creation flags should not change when reloading the extension.
4058   const Extension* extension = service()->GetExtensionById(good_crx, true);
4059   EXPECT_TRUE(extension->from_webstore());
4060   EXPECT_TRUE(extension->was_installed_by_default());
4061   EXPECT_FALSE(extension->from_bookmark());
4062
4063   // Extension counts shouldn't change.
4064   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4065   EXPECT_EQ(1u, registry()->disabled_extensions().size());
4066
4067   service()->EnableExtension(extension_id);
4068
4069   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4070   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4071
4072   // Need to clear |loaded_| manually before reloading as the
4073   // EnableExtension() call above inserted into it and
4074   // UnloadAllExtensions() doesn't send out notifications.
4075   loaded_.clear();
4076   service()->ReloadExtensionsForTest();
4077
4078   // Extension counts shouldn't change.
4079   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4080   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4081 }
4082
4083 // Tests reloading an extension.
4084 TEST_F(ExtensionServiceTest, ReloadExtension) {
4085   InitializeEmptyExtensionService();
4086   InitializeProcessManager();
4087
4088   // Simple extension that should install without error.
4089   const char* extension_id = "behllobkkfkfnphdnhnkndlbkcpglgmj";
4090   base::FilePath ext = data_dir()
4091                            .AppendASCII("good")
4092                            .AppendASCII("Extensions")
4093                            .AppendASCII(extension_id)
4094                            .AppendASCII("1.0.0.0");
4095   extensions::UnpackedInstaller::Create(service())->Load(ext);
4096   base::RunLoop().RunUntilIdle();
4097
4098   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4099   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4100
4101   service()->ReloadExtension(extension_id);
4102
4103   // Extension should be disabled now, waiting to be reloaded.
4104   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4105   EXPECT_EQ(1u, registry()->disabled_extensions().size());
4106   EXPECT_EQ(Extension::DISABLE_RELOAD,
4107             ExtensionPrefs::Get(profile())->GetDisableReasons(extension_id));
4108
4109   // Reloading again should not crash.
4110   service()->ReloadExtension(extension_id);
4111
4112   // Finish reloading
4113   base::RunLoop().RunUntilIdle();
4114
4115   // Extension should be enabled again.
4116   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4117   EXPECT_EQ(0u, registry()->disabled_extensions().size());
4118 }
4119
4120 TEST_F(ExtensionServiceTest, UninstallExtension) {
4121   InitializeEmptyExtensionService();
4122   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
4123   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4124   UninstallExtension(good_crx, false);
4125   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4126   EXPECT_EQ(UnloadedExtensionInfo::REASON_UNINSTALL, unloaded_reason_);
4127 }
4128
4129 TEST_F(ExtensionServiceTest, UninstallTerminatedExtension) {
4130   InitializeEmptyExtensionService();
4131   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
4132   TerminateExtension(good_crx);
4133   UninstallExtension(good_crx, false);
4134   EXPECT_EQ(UnloadedExtensionInfo::REASON_TERMINATE, unloaded_reason_);
4135 }
4136
4137 // Tests the uninstaller helper.
4138 TEST_F(ExtensionServiceTest, UninstallExtensionHelper) {
4139   InitializeEmptyExtensionService();
4140   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
4141   UninstallExtension(good_crx, true);
4142   EXPECT_EQ(UnloadedExtensionInfo::REASON_UNINSTALL, unloaded_reason_);
4143 }
4144
4145 TEST_F(ExtensionServiceTest, UninstallExtensionHelperTerminated) {
4146   InitializeEmptyExtensionService();
4147   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
4148   TerminateExtension(good_crx);
4149   UninstallExtension(good_crx, true);
4150   EXPECT_EQ(UnloadedExtensionInfo::REASON_TERMINATE, unloaded_reason_);
4151 }
4152
4153 // An extension disabled because of unsupported requirements should re-enabled
4154 // if updated to a version with supported requirements as long as there are no
4155 // other disable reasons.
4156 TEST_F(ExtensionServiceTest, UpgradingRequirementsEnabled) {
4157   InitializeEmptyExtensionService();
4158   BlackListWebGL();
4159
4160   base::FilePath path = data_dir().AppendASCII("requirements");
4161   base::FilePath pem_path =
4162       data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
4163   const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
4164                                                     pem_path,
4165                                                     INSTALL_NEW);
4166   std::string id = extension_v1->id();
4167   EXPECT_TRUE(service()->IsExtensionEnabled(id));
4168
4169   base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
4170
4171   PackCRX(path.AppendASCII("v2_bad_requirements"),
4172           pem_path,
4173           v2_bad_requirements_crx);
4174   UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
4175   EXPECT_FALSE(service()->IsExtensionEnabled(id));
4176
4177   base::FilePath v3_good_crx = GetTemporaryFile();
4178
4179   PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
4180   UpdateExtension(id, v3_good_crx, ENABLED);
4181   EXPECT_TRUE(service()->IsExtensionEnabled(id));
4182 }
4183
4184 // Extensions disabled through user action should stay disabled.
4185 TEST_F(ExtensionServiceTest, UpgradingRequirementsDisabled) {
4186   InitializeEmptyExtensionService();
4187   BlackListWebGL();
4188
4189   base::FilePath path = data_dir().AppendASCII("requirements");
4190   base::FilePath pem_path =
4191       data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
4192   const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
4193                                                     pem_path,
4194                                                     INSTALL_NEW);
4195   std::string id = extension_v1->id();
4196   service()->DisableExtension(id, Extension::DISABLE_USER_ACTION);
4197   EXPECT_FALSE(service()->IsExtensionEnabled(id));
4198
4199   base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
4200
4201   PackCRX(path.AppendASCII("v2_bad_requirements"),
4202           pem_path,
4203           v2_bad_requirements_crx);
4204   UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
4205   EXPECT_FALSE(service()->IsExtensionEnabled(id));
4206
4207   base::FilePath v3_good_crx = GetTemporaryFile();
4208
4209   PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
4210   UpdateExtension(id, v3_good_crx, INSTALLED);
4211   EXPECT_FALSE(service()->IsExtensionEnabled(id));
4212 }
4213
4214 // The extension should not re-enabled because it was disabled from a
4215 // permission increase.
4216 TEST_F(ExtensionServiceTest, UpgradingRequirementsPermissions) {
4217   InitializeEmptyExtensionService();
4218   BlackListWebGL();
4219
4220   base::FilePath path = data_dir().AppendASCII("requirements");
4221   base::FilePath pem_path =
4222       data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
4223   const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
4224                                                     pem_path,
4225                                                     INSTALL_NEW);
4226   std::string id = extension_v1->id();
4227   EXPECT_TRUE(service()->IsExtensionEnabled(id));
4228
4229   base::FilePath v2_bad_requirements_and_permissions_crx = GetTemporaryFile();
4230
4231   PackCRX(path.AppendASCII("v2_bad_requirements_and_permissions"),
4232           pem_path,
4233           v2_bad_requirements_and_permissions_crx);
4234   UpdateExtension(id, v2_bad_requirements_and_permissions_crx, INSTALLED);
4235   EXPECT_FALSE(service()->IsExtensionEnabled(id));
4236
4237   base::FilePath v3_bad_permissions_crx = GetTemporaryFile();
4238
4239   PackCRX(path.AppendASCII("v3_bad_permissions"),
4240           pem_path,
4241           v3_bad_permissions_crx);
4242   UpdateExtension(id, v3_bad_permissions_crx, INSTALLED);
4243   EXPECT_FALSE(service()->IsExtensionEnabled(id));
4244 }
4245
4246 // Unpacked extensions are not allowed to be installed if they have unsupported
4247 // requirements.
4248 TEST_F(ExtensionServiceTest, UnpackedRequirements) {
4249   InitializeEmptyExtensionService();
4250   BlackListWebGL();
4251
4252   base::FilePath path =
4253       data_dir().AppendASCII("requirements").AppendASCII("v2_bad_requirements");
4254   extensions::UnpackedInstaller::Create(service())->Load(path);
4255   base::RunLoop().RunUntilIdle();
4256   EXPECT_EQ(1u, GetErrors().size());
4257   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4258 }
4259
4260 class ExtensionCookieCallback {
4261  public:
4262   ExtensionCookieCallback()
4263     : result_(false),
4264       weak_factory_(base::MessageLoop::current()) {}
4265
4266   void SetCookieCallback(bool result) {
4267     base::MessageLoop::current()->PostTask(FROM_HERE,
4268         base::Bind(&base::MessageLoop::Quit, weak_factory_.GetWeakPtr()));
4269     result_ = result;
4270   }
4271
4272   void GetAllCookiesCallback(const net::CookieList& list) {
4273     base::MessageLoop::current()->PostTask(FROM_HERE,
4274         base::Bind(&base::MessageLoop::Quit, weak_factory_.GetWeakPtr()));
4275     list_ = list;
4276   }
4277   net::CookieList list_;
4278   bool result_;
4279   base::WeakPtrFactory<base::MessageLoop> weak_factory_;
4280 };
4281
4282 // Verifies extension state is removed upon uninstall.
4283 TEST_F(ExtensionServiceTest, ClearExtensionData) {
4284   InitializeEmptyExtensionService();
4285   ExtensionCookieCallback callback;
4286
4287   // Load a test extension.
4288   base::FilePath path = data_dir();
4289   path = path.AppendASCII("good.crx");
4290   const Extension* extension = InstallCRX(path, INSTALL_NEW);
4291   ASSERT_TRUE(extension);
4292   GURL ext_url(extension->url());
4293   std::string origin_id = storage::GetIdentifierFromOrigin(ext_url);
4294
4295   // Set a cookie for the extension.
4296   net::CookieMonster* cookie_monster = profile()
4297                                            ->GetRequestContextForExtensions()
4298                                            ->GetURLRequestContext()
4299                                            ->cookie_store()
4300                                            ->GetCookieMonster();
4301   ASSERT_TRUE(cookie_monster);
4302   net::CookieOptions options;
4303   cookie_monster->SetCookieWithOptionsAsync(
4304        ext_url, "dummy=value", options,
4305        base::Bind(&ExtensionCookieCallback::SetCookieCallback,
4306                   base::Unretained(&callback)));
4307   base::RunLoop().RunUntilIdle();
4308   EXPECT_TRUE(callback.result_);
4309
4310   cookie_monster->GetAllCookiesForURLAsync(
4311       ext_url,
4312       base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
4313                  base::Unretained(&callback)));
4314   base::RunLoop().RunUntilIdle();
4315   EXPECT_EQ(1U, callback.list_.size());
4316
4317   // Open a database.
4318   storage::DatabaseTracker* db_tracker =
4319       BrowserContext::GetDefaultStoragePartition(profile())
4320           ->GetDatabaseTracker();
4321   base::string16 db_name = base::UTF8ToUTF16("db");
4322   base::string16 description = base::UTF8ToUTF16("db_description");
4323   int64 size;
4324   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
4325   db_tracker->DatabaseClosed(origin_id, db_name);
4326   std::vector<storage::OriginInfo> origins;
4327   db_tracker->GetAllOriginsInfo(&origins);
4328   EXPECT_EQ(1U, origins.size());
4329   EXPECT_EQ(origin_id, origins[0].GetOriginIdentifier());
4330
4331   // Create local storage. We only simulate this by creating the backing files.
4332   // Note: This test depends on details of how the dom_storage library
4333   // stores data in the host file system.
4334   base::FilePath lso_dir_path =
4335       profile()->GetPath().AppendASCII("Local Storage");
4336   base::FilePath lso_file_path = lso_dir_path.AppendASCII(origin_id)
4337       .AddExtension(FILE_PATH_LITERAL(".localstorage"));
4338   EXPECT_TRUE(base::CreateDirectory(lso_dir_path));
4339   EXPECT_EQ(0, base::WriteFile(lso_file_path, NULL, 0));
4340   EXPECT_TRUE(base::PathExists(lso_file_path));
4341
4342   // Create indexed db. Similarly, it is enough to only simulate this by
4343   // creating the directory on the disk.
4344   IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
4345                                       profile())->GetIndexedDBContext();
4346   idb_context->SetTaskRunnerForTesting(
4347       base::MessageLoop::current()->message_loop_proxy().get());
4348   base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
4349   EXPECT_TRUE(base::CreateDirectory(idb_path));
4350   EXPECT_TRUE(base::DirectoryExists(idb_path));
4351
4352   // Uninstall the extension.
4353   base::RunLoop run_loop;
4354   ASSERT_TRUE(
4355       service()->UninstallExtension(good_crx,
4356                                     extensions::UNINSTALL_REASON_FOR_TESTING,
4357                                     run_loop.QuitClosure(),
4358                                     NULL));
4359   // The data deletion happens on the IO thread.
4360   run_loop.Run();
4361
4362   // Check that the cookie is gone.
4363   cookie_monster->GetAllCookiesForURLAsync(
4364        ext_url,
4365        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
4366                   base::Unretained(&callback)));
4367   base::RunLoop().RunUntilIdle();
4368   EXPECT_EQ(0U, callback.list_.size());
4369
4370   // The database should have vanished as well.
4371   origins.clear();
4372   db_tracker->GetAllOriginsInfo(&origins);
4373   EXPECT_EQ(0U, origins.size());
4374
4375   // Check that the LSO file has been removed.
4376   EXPECT_FALSE(base::PathExists(lso_file_path));
4377
4378   // Check if the indexed db has disappeared too.
4379   EXPECT_FALSE(base::DirectoryExists(idb_path));
4380 }
4381
4382 // Verifies app state is removed upon uninstall.
4383 TEST_F(ExtensionServiceTest, ClearAppData) {
4384   InitializeEmptyExtensionService();
4385   ExtensionCookieCallback callback;
4386
4387   int pref_count = 0;
4388
4389   // Install app1 with unlimited storage.
4390   const Extension* extension =
4391       PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
4392   ValidatePrefKeyCount(++pref_count);
4393   ASSERT_EQ(1u, registry()->enabled_extensions().size());
4394   const std::string id1 = extension->id();
4395   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
4396       APIPermission::kUnlimitedStorage));
4397   const GURL origin1(
4398       extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
4399   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
4400       origin1));
4401   std::string origin_id = storage::GetIdentifierFromOrigin(origin1);
4402
4403   // Install app2 from the same origin with unlimited storage.
4404   extension = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
4405   ValidatePrefKeyCount(++pref_count);
4406   ASSERT_EQ(2u, registry()->enabled_extensions().size());
4407   const std::string id2 = extension->id();
4408   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
4409       APIPermission::kUnlimitedStorage));
4410   EXPECT_TRUE(extension->web_extent().MatchesURL(
4411       extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
4412   const GURL origin2(
4413       extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
4414   EXPECT_EQ(origin1, origin2);
4415   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
4416       origin2));
4417
4418   // Set a cookie for the extension.
4419   net::CookieMonster* cookie_monster = profile()
4420                                            ->GetRequestContext()
4421                                            ->GetURLRequestContext()
4422                                            ->cookie_store()
4423                                            ->GetCookieMonster();
4424   ASSERT_TRUE(cookie_monster);
4425   net::CookieOptions options;
4426   cookie_monster->SetCookieWithOptionsAsync(
4427        origin1, "dummy=value", options,
4428        base::Bind(&ExtensionCookieCallback::SetCookieCallback,
4429                   base::Unretained(&callback)));
4430   base::RunLoop().RunUntilIdle();
4431   EXPECT_TRUE(callback.result_);
4432
4433   cookie_monster->GetAllCookiesForURLAsync(
4434       origin1,
4435       base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
4436                  base::Unretained(&callback)));
4437   base::RunLoop().RunUntilIdle();
4438   EXPECT_EQ(1U, callback.list_.size());
4439
4440   // Open a database.
4441   storage::DatabaseTracker* db_tracker =
4442       BrowserContext::GetDefaultStoragePartition(profile())
4443           ->GetDatabaseTracker();
4444   base::string16 db_name = base::UTF8ToUTF16("db");
4445   base::string16 description = base::UTF8ToUTF16("db_description");
4446   int64 size;
4447   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
4448   db_tracker->DatabaseClosed(origin_id, db_name);
4449   std::vector<storage::OriginInfo> origins;
4450   db_tracker->GetAllOriginsInfo(&origins);
4451   EXPECT_EQ(1U, origins.size());
4452   EXPECT_EQ(origin_id, origins[0].GetOriginIdentifier());
4453
4454   // Create local storage. We only simulate this by creating the backing files.
4455   // Note: This test depends on details of how the dom_storage library
4456   // stores data in the host file system.
4457   base::FilePath lso_dir_path =
4458       profile()->GetPath().AppendASCII("Local Storage");
4459   base::FilePath lso_file_path = lso_dir_path.AppendASCII(origin_id)
4460       .AddExtension(FILE_PATH_LITERAL(".localstorage"));
4461   EXPECT_TRUE(base::CreateDirectory(lso_dir_path));
4462   EXPECT_EQ(0, base::WriteFile(lso_file_path, NULL, 0));
4463   EXPECT_TRUE(base::PathExists(lso_file_path));
4464
4465   // Create indexed db. Similarly, it is enough to only simulate this by
4466   // creating the directory on the disk.
4467   IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
4468                                       profile())->GetIndexedDBContext();
4469   idb_context->SetTaskRunnerForTesting(
4470       base::MessageLoop::current()->message_loop_proxy().get());
4471   base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
4472   EXPECT_TRUE(base::CreateDirectory(idb_path));
4473   EXPECT_TRUE(base::DirectoryExists(idb_path));
4474
4475   // Uninstall one of them, unlimited storage should still be granted
4476   // to the origin.
4477   UninstallExtension(id1, false);
4478   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4479   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
4480       origin1));
4481
4482   // Check that the cookie is still there.
4483   cookie_monster->GetAllCookiesForURLAsync(
4484        origin1,
4485        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
4486                   base::Unretained(&callback)));
4487   base::RunLoop().RunUntilIdle();
4488   EXPECT_EQ(1U, callback.list_.size());
4489
4490   // Now uninstall the other. Storage should be cleared for the apps.
4491   UninstallExtension(id2, false);
4492   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4493   EXPECT_FALSE(
4494       profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
4495           origin1));
4496
4497   // Check that the cookie is gone.
4498   cookie_monster->GetAllCookiesForURLAsync(
4499        origin1,
4500        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
4501                   base::Unretained(&callback)));
4502   base::RunLoop().RunUntilIdle();
4503   EXPECT_EQ(0U, callback.list_.size());
4504
4505   // The database should have vanished as well.
4506   origins.clear();
4507   db_tracker->GetAllOriginsInfo(&origins);
4508   EXPECT_EQ(0U, origins.size());
4509
4510   // Check that the LSO file has been removed.
4511   EXPECT_FALSE(base::PathExists(lso_file_path));
4512
4513   // Check if the indexed db has disappeared too.
4514   EXPECT_FALSE(base::DirectoryExists(idb_path));
4515 }
4516
4517 // Tests loading single extensions (like --load-extension)
4518 // Flaky crashes. http://crbug.com/231806
4519 TEST_F(ExtensionServiceTest, DISABLED_LoadExtension) {
4520   InitializeEmptyExtensionService();
4521
4522   base::FilePath ext1 = data_dir()
4523                             .AppendASCII("good")
4524                             .AppendASCII("Extensions")
4525                             .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
4526                             .AppendASCII("1.0.0.0");
4527   extensions::UnpackedInstaller::Create(service())->Load(ext1);
4528   base::RunLoop().RunUntilIdle();
4529   EXPECT_EQ(0u, GetErrors().size());
4530   ASSERT_EQ(1u, loaded_.size());
4531   EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
4532   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4533
4534   ValidatePrefKeyCount(1);
4535
4536   base::FilePath no_manifest =
4537       data_dir()
4538           .AppendASCII("bad")
4539           // .AppendASCII("Extensions")
4540           .AppendASCII("cccccccccccccccccccccccccccccccc")
4541           .AppendASCII("1");
4542   extensions::UnpackedInstaller::Create(service())->Load(no_manifest);
4543   base::RunLoop().RunUntilIdle();
4544   EXPECT_EQ(1u, GetErrors().size());
4545   ASSERT_EQ(1u, loaded_.size());
4546   EXPECT_EQ(1u, registry()->enabled_extensions().size());
4547
4548   // Test uninstall.
4549   std::string id = loaded_[0]->id();
4550   EXPECT_FALSE(unloaded_id_.length());
4551   service()->UninstallExtension(id,
4552                                 extensions::UNINSTALL_REASON_FOR_TESTING,
4553                                 base::Bind(&base::DoNothing),
4554                                 NULL);
4555   base::RunLoop().RunUntilIdle();
4556   EXPECT_EQ(id, unloaded_id_);
4557   ASSERT_EQ(0u, loaded_.size());
4558   EXPECT_EQ(0u, registry()->enabled_extensions().size());
4559 }
4560
4561 // Tests that we generate IDs when they are not specified in the manifest for
4562 // --load-extension.
4563 TEST_F(ExtensionServiceTest, GenerateID) {
4564   InitializeEmptyExtensionService();
4565
4566   base::FilePath no_id_ext = data_dir().AppendASCII("no_id");
4567   extensions::UnpackedInstaller::Create(service())->Load(no_id_ext);
4568   base::RunLoop().RunUntilIdle();
4569   EXPECT_EQ(0u, GetErrors().size());
4570   ASSERT_EQ(1u, loaded_.size());
4571   ASSERT_TRUE(crx_file::id_util::IdIsValid(loaded_[0]->id()));
4572   EXPECT_EQ(loaded_[0]->location(), Manifest::UNPACKED);
4573
4574   ValidatePrefKeyCount(1);
4575
4576   std::string previous_id = loaded_[0]->id();
4577
4578   // If we reload the same path, we should get the same extension ID.
4579   extensions::UnpackedInstaller::Create(service())->Load(no_id_ext);
4580   base::RunLoop().RunUntilIdle();
4581   ASSERT_EQ(1u, loaded_.size());
4582   ASSERT_EQ(previous_id, loaded_[0]->id());
4583 }
4584
4585 TEST_F(ExtensionServiceTest, UnpackedValidatesLocales) {
4586   InitializeEmptyExtensionService();
4587
4588   base::FilePath bad_locale =
4589       data_dir().AppendASCII("unpacked").AppendASCII("bad_messages_file");
4590   extensions::UnpackedInstaller::Create(service())->Load(bad_locale);
4591   base::RunLoop().RunUntilIdle();
4592   EXPECT_EQ(1u, GetErrors().size());
4593   base::FilePath ms_messages_file = bad_locale.AppendASCII("_locales")
4594                                               .AppendASCII("ms")
4595                                               .AppendASCII("messages.json");
4596   EXPECT_THAT(base::UTF16ToUTF8(GetErrors()[0]), testing::AllOf(
4597        testing::HasSubstr(
4598            base::UTF16ToUTF8(ms_messages_file.LossyDisplayName())),
4599        testing::HasSubstr("Dictionary keys must be quoted.")));
4600   ASSERT_EQ(0u, loaded_.size());
4601 }
4602
4603 void ExtensionServiceTest::TestExternalProvider(
4604     MockExtensionProvider* provider, Manifest::Location location) {
4605   // Verify that starting with no providers loads no extensions.
4606   service()->Init();
4607   ASSERT_EQ(0u, loaded_.size());
4608
4609   provider->set_visit_count(0);
4610
4611   // Register a test extension externally using the mock registry provider.
4612   base::FilePath source_path = data_dir().AppendASCII("good.crx");
4613
4614   // Add the extension.
4615   provider->UpdateOrAddExtension(good_crx, "1.0.0.0", source_path);
4616
4617   // Reloading extensions should find our externally registered extension
4618   // and install it.
4619   content::WindowedNotificationObserver observer(
4620       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
4621       content::NotificationService::AllSources());
4622   service()->CheckForExternalUpdates();
4623   observer.Wait();
4624
4625   ASSERT_EQ(0u, GetErrors().size());
4626   ASSERT_EQ(1u, loaded_.size());
4627   ASSERT_EQ(location, loaded_[0]->location());
4628   ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
4629   ValidatePrefKeyCount(1);
4630   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
4631   ValidateIntegerPref(good_crx, "location", location);
4632
4633   // Reload extensions without changing anything. The extension should be
4634   // loaded again.
4635   loaded_.clear();
4636   service()->ReloadExtensionsForTest();
4637   base::RunLoop().RunUntilIdle();
4638   ASSERT_EQ(0u, GetErrors().size());
4639   ASSERT_EQ(1u, loaded_.size());
4640   ValidatePrefKeyCount(1);
4641   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
4642   ValidateIntegerPref(good_crx, "location", location);
4643
4644   // Now update the extension with a new version. We should get upgraded.
4645   source_path = source_path.DirName().AppendASCII("good2.crx");
4646   provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
4647
4648   loaded_.clear();
4649   content::WindowedNotificationObserver observer_2(
4650       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
4651       content::NotificationService::AllSources());
4652   service()->CheckForExternalUpdates();
4653   observer_2.Wait();
4654   ASSERT_EQ(0u, GetErrors().size());
4655   ASSERT_EQ(1u, loaded_.size());
4656   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
4657   ValidatePrefKeyCount(1);
4658   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
4659   ValidateIntegerPref(good_crx, "location", location);
4660
4661   // Uninstall the extension and reload. Nothing should happen because the
4662   // preference should prevent us from reinstalling.
4663   std::string id = loaded_[0]->id();
4664   bool no_uninstall =
4665       GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL);
4666   service()->UninstallExtension(id,
4667                                 extensions::UNINSTALL_REASON_FOR_TESTING,
4668                                 base::Bind(&base::DoNothing),
4669                                 NULL);
4670   base::RunLoop().RunUntilIdle();
4671
4672   base::FilePath install_path = extensions_install_dir().AppendASCII(id);
4673   if (no_uninstall) {
4674     // Policy controlled extensions should not have been touched by uninstall.
4675     ASSERT_TRUE(base::PathExists(install_path));
4676   } else {
4677     // The extension should also be gone from the install directory.
4678     ASSERT_FALSE(base::PathExists(install_path));
4679     loaded_.clear();
4680     service()->CheckForExternalUpdates();
4681     base::RunLoop().RunUntilIdle();
4682     ASSERT_EQ(0u, loaded_.size());
4683     ValidatePrefKeyCount(1);
4684     ValidateIntegerPref(good_crx, "state",
4685                         Extension::EXTERNAL_EXTENSION_UNINSTALLED);
4686     ValidateIntegerPref(good_crx, "location", location);
4687
4688     // Now clear the preference and reinstall.
4689     SetPrefInteg(good_crx, "state", Extension::ENABLED);
4690
4691     loaded_.clear();
4692     content::WindowedNotificationObserver observer(
4693         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
4694         content::NotificationService::AllSources());
4695     service()->CheckForExternalUpdates();
4696     observer.Wait();
4697     ASSERT_EQ(1u, loaded_.size());
4698   }
4699   ValidatePrefKeyCount(1);
4700   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
4701   ValidateIntegerPref(good_crx, "location", location);
4702
4703   if (GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL)) {
4704     EXPECT_EQ(2, provider->visit_count());
4705   } else {
4706     // Now test an externally triggered uninstall (deleting the registry key or
4707     // the pref entry).
4708     provider->RemoveExtension(good_crx);
4709
4710     loaded_.clear();
4711     service()->OnExternalProviderReady(provider);
4712     base::RunLoop().RunUntilIdle();
4713     ASSERT_EQ(0u, loaded_.size());
4714     ValidatePrefKeyCount(0);
4715
4716     // The extension should also be gone from the install directory.
4717     ASSERT_FALSE(base::PathExists(install_path));
4718
4719     // Now test the case where user uninstalls and then the extension is removed
4720     // from the external provider.
4721     content::WindowedNotificationObserver observer(
4722         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
4723         content::NotificationService::AllSources());
4724     provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
4725     service()->CheckForExternalUpdates();
4726     observer.Wait();
4727
4728     ASSERT_EQ(1u, loaded_.size());
4729     ASSERT_EQ(0u, GetErrors().size());
4730
4731     // User uninstalls.
4732     loaded_.clear();
4733     service()->UninstallExtension(id,
4734                                   extensions::UNINSTALL_REASON_FOR_TESTING,
4735                                   base::Bind(&base::DoNothing),
4736                                   NULL);
4737     base::RunLoop().RunUntilIdle();
4738     ASSERT_EQ(0u, loaded_.size());
4739
4740     // Then remove the extension from the extension provider.
4741     provider->RemoveExtension(good_crx);
4742
4743     // Should still be at 0.
4744     loaded_.clear();
4745     extensions::InstalledLoader(service()).LoadAllExtensions();
4746     base::RunLoop().RunUntilIdle();
4747     ASSERT_EQ(0u, loaded_.size());
4748     ValidatePrefKeyCount(1);
4749
4750     EXPECT_EQ(5, provider->visit_count());
4751   }
4752 }
4753
4754 // Tests the external installation feature
4755 #if defined(OS_WIN)
4756 TEST_F(ExtensionServiceTest, ExternalInstallRegistry) {
4757   // This should all work, even when normal extension installation is disabled.
4758   InitializeEmptyExtensionService();
4759   service()->set_extensions_enabled(false);
4760
4761   // Now add providers. Extension system takes ownership of the objects.
4762   MockExtensionProvider* reg_provider =
4763       new MockExtensionProvider(service(), Manifest::EXTERNAL_REGISTRY);
4764   AddMockExternalProvider(reg_provider);
4765   TestExternalProvider(reg_provider, Manifest::EXTERNAL_REGISTRY);
4766 }
4767 #endif
4768
4769 TEST_F(ExtensionServiceTest, ExternalInstallPref) {
4770   InitializeEmptyExtensionService();
4771
4772   // Now add providers. Extension system takes ownership of the objects.
4773   MockExtensionProvider* pref_provider =
4774       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
4775
4776   AddMockExternalProvider(pref_provider);
4777   TestExternalProvider(pref_provider, Manifest::EXTERNAL_PREF);
4778 }
4779
4780 TEST_F(ExtensionServiceTest, ExternalInstallPrefUpdateUrl) {
4781   // This should all work, even when normal extension installation is disabled.
4782   InitializeEmptyExtensionService();
4783   service()->set_extensions_enabled(false);
4784
4785   // TODO(skerner): The mock provider is not a good model of a provider
4786   // that works with update URLs, because it adds file and version info.
4787   // Extend the mock to work with update URLs.  This test checks the
4788   // behavior that is common to all external extension visitors.  The
4789   // browser test ExtensionManagementTest.ExternalUrlUpdate tests that
4790   // what the visitor does results in an extension being downloaded and
4791   // installed.
4792   MockExtensionProvider* pref_provider =
4793       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF_DOWNLOAD);
4794   AddMockExternalProvider(pref_provider);
4795   TestExternalProvider(pref_provider, Manifest::EXTERNAL_PREF_DOWNLOAD);
4796 }
4797
4798 TEST_F(ExtensionServiceTest, ExternalInstallPolicyUpdateUrl) {
4799   // This should all work, even when normal extension installation is disabled.
4800   InitializeEmptyExtensionService();
4801   service()->set_extensions_enabled(false);
4802
4803   // TODO(skerner): The mock provider is not a good model of a provider
4804   // that works with update URLs, because it adds file and version info.
4805   // Extend the mock to work with update URLs. This test checks the
4806   // behavior that is common to all external extension visitors. The
4807   // browser test ExtensionManagementTest.ExternalUrlUpdate tests that
4808   // what the visitor does results in an extension being downloaded and
4809   // installed.
4810   MockExtensionProvider* pref_provider =
4811       new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
4812   AddMockExternalProvider(pref_provider);
4813   TestExternalProvider(pref_provider, Manifest::EXTERNAL_POLICY_DOWNLOAD);
4814 }
4815
4816 // Tests that external extensions get uninstalled when the external extension
4817 // providers can't account for them.
4818 TEST_F(ExtensionServiceTest, ExternalUninstall) {
4819   // Start the extensions service with one external extension already installed.
4820   base::FilePath source_install_dir =
4821       data_dir().AppendASCII("good").AppendASCII("Extensions");
4822   base::FilePath pref_path = source_install_dir
4823       .DirName()
4824       .AppendASCII("PreferencesExternal");
4825
4826   // This initializes the extensions service with no ExternalProviders.
4827   InitializeInstalledExtensionService(pref_path, source_install_dir);
4828   service()->set_extensions_enabled(false);
4829
4830   service()->Init();
4831
4832   ASSERT_EQ(0u, GetErrors().size());
4833   ASSERT_EQ(0u, loaded_.size());
4834
4835   // Verify that it's not the disabled extensions flag causing it not to load.
4836   service()->set_extensions_enabled(true);
4837   service()->ReloadExtensionsForTest();
4838   base::RunLoop().RunUntilIdle();
4839
4840   ASSERT_EQ(0u, GetErrors().size());
4841   ASSERT_EQ(0u, loaded_.size());
4842 }
4843
4844 // Test that running multiple update checks simultaneously does not
4845 // keep the update from succeeding.
4846 TEST_F(ExtensionServiceTest, MultipleExternalUpdateCheck) {
4847   InitializeEmptyExtensionService();
4848
4849   MockExtensionProvider* provider =
4850       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
4851   AddMockExternalProvider(provider);
4852
4853   // Verify that starting with no providers loads no extensions.
4854   service()->Init();
4855   ASSERT_EQ(0u, loaded_.size());
4856
4857   // Start two checks for updates.
4858   provider->set_visit_count(0);
4859   service()->CheckForExternalUpdates();
4860   service()->CheckForExternalUpdates();
4861   base::RunLoop().RunUntilIdle();
4862
4863   // Two calls should cause two checks for external extensions.
4864   EXPECT_EQ(2, provider->visit_count());
4865   EXPECT_EQ(0u, GetErrors().size());
4866   EXPECT_EQ(0u, loaded_.size());
4867
4868   // Register a test extension externally using the mock registry provider.
4869   base::FilePath source_path = data_dir().AppendASCII("good.crx");
4870   provider->UpdateOrAddExtension(good_crx, "1.0.0.0", source_path);
4871
4872   // Two checks for external updates should find the extension, and install it
4873   // once.
4874   content::WindowedNotificationObserver observer(
4875       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
4876       content::NotificationService::AllSources());
4877   provider->set_visit_count(0);
4878   service()->CheckForExternalUpdates();
4879   service()->CheckForExternalUpdates();
4880   observer.Wait();
4881   EXPECT_EQ(2, provider->visit_count());
4882   ASSERT_EQ(0u, GetErrors().size());
4883   ASSERT_EQ(1u, loaded_.size());
4884   ASSERT_EQ(Manifest::EXTERNAL_PREF, loaded_[0]->location());
4885   ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
4886   ValidatePrefKeyCount(1);
4887   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
4888   ValidateIntegerPref(good_crx, "location", Manifest::EXTERNAL_PREF);
4889
4890   provider->RemoveExtension(good_crx);
4891   provider->set_visit_count(0);
4892   service()->CheckForExternalUpdates();
4893   service()->CheckForExternalUpdates();
4894   base::RunLoop().RunUntilIdle();
4895
4896   // Two calls should cause two checks for external extensions.
4897   // Because the external source no longer includes good_crx,
4898   // good_crx will be uninstalled.  So, expect that no extensions
4899   // are loaded.
4900   EXPECT_EQ(2, provider->visit_count());
4901   EXPECT_EQ(0u, GetErrors().size());
4902   EXPECT_EQ(0u, loaded_.size());
4903 }
4904
4905 TEST_F(ExtensionServiceTest, ExternalPrefProvider) {
4906   InitializeEmptyExtensionService();
4907
4908   // Test some valid extension records.
4909   // Set a base path to avoid erroring out on relative paths.
4910   // Paths starting with // are absolute on every platform we support.
4911   base::FilePath base_path(FILE_PATH_LITERAL("//base/path"));
4912   ASSERT_TRUE(base_path.IsAbsolute());
4913   MockProviderVisitor visitor(base_path);
4914   std::string json_data =
4915       "{"
4916       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
4917       "    \"external_crx\": \"RandomExtension.crx\","
4918       "    \"external_version\": \"1.0\""
4919       "  },"
4920       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
4921       "    \"external_crx\": \"RandomExtension2.crx\","
4922       "    \"external_version\": \"2.0\""
4923       "  },"
4924       "  \"cccccccccccccccccccccccccccccccc\": {"
4925       "    \"external_update_url\": \"http:\\\\foo.com/update\","
4926       "    \"install_parameter\": \"id\""
4927       "  }"
4928       "}";
4929   EXPECT_EQ(3, visitor.Visit(json_data));
4930
4931   // Simulate an external_extensions.json file that contains seven invalid
4932   // records:
4933   // - One that is missing the 'external_crx' key.
4934   // - One that is missing the 'external_version' key.
4935   // - One that is specifying .. in the path.
4936   // - One that specifies both a file and update URL.
4937   // - One that specifies no file or update URL.
4938   // - One that has an update URL that is not well formed.
4939   // - One that contains a malformed version.
4940   // - One that has an invalid id.
4941   // - One that has a non-dictionary value.
4942   // - One that has an integer 'external_version' instead of a string.
4943   // The final extension is valid, and we check that it is read to make sure
4944   // failures don't stop valid records from being read.
4945   json_data =
4946       "{"
4947       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
4948       "    \"external_version\": \"1.0\""
4949       "  },"
4950       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
4951       "    \"external_crx\": \"RandomExtension.crx\""
4952       "  },"
4953       "  \"cccccccccccccccccccccccccccccccc\": {"
4954       "    \"external_crx\": \"..\\\\foo\\\\RandomExtension2.crx\","
4955       "    \"external_version\": \"2.0\""
4956       "  },"
4957       "  \"dddddddddddddddddddddddddddddddd\": {"
4958       "    \"external_crx\": \"RandomExtension2.crx\","
4959       "    \"external_version\": \"2.0\","
4960       "    \"external_update_url\": \"http:\\\\foo.com/update\""
4961       "  },"
4962       "  \"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\": {"
4963       "  },"
4964       "  \"ffffffffffffffffffffffffffffffff\": {"
4965       "    \"external_update_url\": \"This string is not a valid URL\""
4966       "  },"
4967       "  \"gggggggggggggggggggggggggggggggg\": {"
4968       "    \"external_crx\": \"RandomExtension3.crx\","
4969       "    \"external_version\": \"This is not a valid version!\""
4970       "  },"
4971       "  \"This is not a valid id!\": {},"
4972       "  \"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\": true,"
4973       "  \"iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\": {"
4974       "    \"external_crx\": \"RandomExtension4.crx\","
4975       "    \"external_version\": 1.0"
4976       "  },"
4977       "  \"pppppppppppppppppppppppppppppppp\": {"
4978       "    \"external_crx\": \"RandomValidExtension.crx\","
4979       "    \"external_version\": \"1.0\""
4980       "  }"
4981       "}";
4982   EXPECT_EQ(1, visitor.Visit(json_data));
4983
4984   // Check that if a base path is not provided, use of a relative
4985   // path fails.
4986   base::FilePath empty;
4987   MockProviderVisitor visitor_no_relative_paths(empty);
4988
4989   // Use absolute paths.  Expect success.
4990   json_data =
4991       "{"
4992       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
4993       "    \"external_crx\": \"//RandomExtension1.crx\","
4994       "    \"external_version\": \"3.0\""
4995       "  },"
4996       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
4997       "    \"external_crx\": \"//path/to/RandomExtension2.crx\","
4998       "    \"external_version\": \"3.0\""
4999       "  }"
5000       "}";
5001   EXPECT_EQ(2, visitor_no_relative_paths.Visit(json_data));
5002
5003   // Use a relative path.  Expect that it will error out.
5004   json_data =
5005       "{"
5006       "  \"cccccccccccccccccccccccccccccccc\": {"
5007       "    \"external_crx\": \"RandomExtension2.crx\","
5008       "    \"external_version\": \"3.0\""
5009       "  }"
5010       "}";
5011   EXPECT_EQ(0, visitor_no_relative_paths.Visit(json_data));
5012
5013   // Test supported_locales.
5014   json_data =
5015       "{"
5016       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
5017       "    \"external_crx\": \"RandomExtension.crx\","
5018       "    \"external_version\": \"1.0\","
5019       "    \"supported_locales\": [ \"en\" ]"
5020       "  },"
5021       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
5022       "    \"external_crx\": \"RandomExtension2.crx\","
5023       "    \"external_version\": \"2.0\","
5024       "    \"supported_locales\": [ \"en-GB\" ]"
5025       "  },"
5026       "  \"cccccccccccccccccccccccccccccccc\": {"
5027       "    \"external_crx\": \"RandomExtension2.crx\","
5028       "    \"external_version\": \"3.0\","
5029       "    \"supported_locales\": [ \"en_US\", \"fr\" ]"
5030       "  }"
5031       "}";
5032   {
5033     ScopedBrowserLocale guard("en-US");
5034     EXPECT_EQ(2, visitor.Visit(json_data));
5035   }
5036
5037   // Test keep_if_present.
5038   json_data =
5039       "{"
5040       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
5041       "    \"external_crx\": \"RandomExtension.crx\","
5042       "    \"external_version\": \"1.0\","
5043       "    \"keep_if_present\": true"
5044       "  }"
5045       "}";
5046   {
5047     EXPECT_EQ(0, visitor.Visit(json_data));
5048   }
5049
5050   // Test is_bookmark_app.
5051   MockProviderVisitor from_bookmark_visitor(
5052       base_path, Extension::FROM_BOOKMARK);
5053   json_data =
5054       "{"
5055       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
5056       "    \"external_crx\": \"RandomExtension.crx\","
5057       "    \"external_version\": \"1.0\","
5058       "    \"is_bookmark_app\": true"
5059       "  }"
5060       "}";
5061   EXPECT_EQ(1, from_bookmark_visitor.Visit(json_data));
5062
5063   // Test is_from_webstore.
5064   MockProviderVisitor from_webstore_visitor(
5065       base_path, Extension::FROM_WEBSTORE);
5066   json_data =
5067       "{"
5068       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
5069       "    \"external_crx\": \"RandomExtension.crx\","
5070       "    \"external_version\": \"1.0\","
5071       "    \"is_from_webstore\": true"
5072       "  }"
5073       "}";
5074   EXPECT_EQ(1, from_webstore_visitor.Visit(json_data));
5075
5076   // Test was_installed_by_eom.
5077   MockProviderVisitor was_installed_by_eom_visitor(
5078       base_path, Extension::WAS_INSTALLED_BY_OEM);
5079   json_data =
5080       "{"
5081       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
5082       "    \"external_crx\": \"RandomExtension.crx\","
5083       "    \"external_version\": \"1.0\","
5084       "    \"was_installed_by_oem\": true"
5085       "  }"
5086       "}";
5087   EXPECT_EQ(1, was_installed_by_eom_visitor.Visit(json_data));
5088 }
5089
5090 // Test loading good extensions from the profile directory.
5091 TEST_F(ExtensionServiceTest, LoadAndRelocalizeExtensions) {
5092   // Ensure we're testing in "en" and leave global state untouched.
5093   extension_l10n_util::ScopedLocaleForTest testLocale("en");
5094
5095   // Initialize the test dir with a good Preferences/extensions.
5096   base::FilePath source_install_dir = data_dir().AppendASCII("l10n");
5097   base::FilePath pref_path =
5098       source_install_dir.Append(chrome::kPreferencesFilename);
5099   InitializeInstalledExtensionService(pref_path, source_install_dir);
5100
5101   service()->Init();
5102
5103   ASSERT_EQ(3u, loaded_.size());
5104
5105   // This was equal to "sr" on load.
5106   ValidateStringPref(loaded_[0]->id(), keys::kCurrentLocale, "en");
5107
5108   // These are untouched by re-localization.
5109   ValidateStringPref(loaded_[1]->id(), keys::kCurrentLocale, "en");
5110   EXPECT_FALSE(IsPrefExist(loaded_[1]->id(), keys::kCurrentLocale));
5111
5112   // This one starts with Serbian name, and gets re-localized into English.
5113   EXPECT_EQ("My name is simple.", loaded_[0]->name());
5114
5115   // These are untouched by re-localization.
5116   EXPECT_EQ("My name is simple.", loaded_[1]->name());
5117   EXPECT_EQ("no l10n", loaded_[2]->name());
5118 }
5119
5120 class ExtensionsReadyRecorder : public content::NotificationObserver {
5121  public:
5122   ExtensionsReadyRecorder() : ready_(false) {
5123     registrar_.Add(this,
5124                    extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
5125                    content::NotificationService::AllSources());
5126   }
5127
5128   void set_ready(bool value) { ready_ = value; }
5129   bool ready() { return ready_; }
5130
5131  private:
5132   virtual void Observe(int type,
5133                        const content::NotificationSource& source,
5134                        const content::NotificationDetails& details) OVERRIDE {
5135     switch (type) {
5136       case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED:
5137         ready_ = true;
5138         break;
5139       default:
5140         NOTREACHED();
5141     }
5142   }
5143
5144   content::NotificationRegistrar registrar_;
5145   bool ready_;
5146 };
5147
5148 // Test that we get enabled/disabled correctly for all the pref/command-line
5149 // combinations. We don't want to derive from the ExtensionServiceTest class
5150 // for this test, so we use ExtensionServiceTestSimple.
5151 //
5152 // Also tests that we always fire EXTENSIONS_READY, no matter whether we are
5153 // enabled or not.
5154 TEST(ExtensionServiceTestSimple, Enabledness) {
5155   // Make sure the PluginService singleton is destroyed at the end of the test.
5156   base::ShadowingAtExitManager at_exit_manager;
5157 #if defined(ENABLE_PLUGINS)
5158   content::PluginService::GetInstance()->Init();
5159   content::PluginService::GetInstance()->DisablePluginsDiscoveryForTesting();
5160 #endif
5161
5162   ExtensionErrorReporter::Init(false);  // no noisy errors
5163   ExtensionsReadyRecorder recorder;
5164   scoped_ptr<TestingProfile> profile(new TestingProfile());
5165   content::TestBrowserThreadBundle thread_bundle_;
5166 #if defined OS_CHROMEOS
5167   chromeos::ScopedTestDeviceSettingsService device_settings_service;
5168   chromeos::ScopedTestCrosSettings cros_settings;
5169   scoped_ptr<chromeos::ScopedTestUserManager> user_manager(
5170       new chromeos::ScopedTestUserManager);
5171 #endif
5172   scoped_ptr<CommandLine> command_line;
5173   base::FilePath install_dir = profile->GetPath()
5174       .AppendASCII(extensions::kInstallDirectoryName);
5175
5176   // By default, we are enabled.
5177   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
5178   ExtensionService* service = static_cast<extensions::TestExtensionSystem*>(
5179       ExtensionSystem::Get(profile.get()))->
5180       CreateExtensionService(
5181           command_line.get(),
5182           install_dir,
5183           false);
5184   EXPECT_TRUE(service->extensions_enabled());
5185   service->Init();
5186   base::RunLoop().RunUntilIdle();
5187   EXPECT_TRUE(recorder.ready());
5188 #if defined OS_CHROMEOS
5189   user_manager.reset();
5190 #endif
5191
5192   // If either the command line or pref is set, we are disabled.
5193   recorder.set_ready(false);
5194   profile.reset(new TestingProfile());
5195   command_line->AppendSwitch(switches::kDisableExtensions);
5196   service = static_cast<extensions::TestExtensionSystem*>(
5197       ExtensionSystem::Get(profile.get()))->
5198       CreateExtensionService(
5199           command_line.get(),
5200           install_dir,
5201           false);
5202   EXPECT_FALSE(service->extensions_enabled());
5203   service->Init();
5204   base::RunLoop().RunUntilIdle();
5205   EXPECT_TRUE(recorder.ready());
5206
5207   recorder.set_ready(false);
5208   profile.reset(new TestingProfile());
5209   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
5210   service = static_cast<extensions::TestExtensionSystem*>(
5211       ExtensionSystem::Get(profile.get()))->
5212       CreateExtensionService(
5213           command_line.get(),
5214           install_dir,
5215           false);
5216   EXPECT_FALSE(service->extensions_enabled());
5217   service->Init();
5218   base::RunLoop().RunUntilIdle();
5219   EXPECT_TRUE(recorder.ready());
5220
5221   recorder.set_ready(false);
5222   profile.reset(new TestingProfile());
5223   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
5224   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
5225   service = static_cast<extensions::TestExtensionSystem*>(
5226       ExtensionSystem::Get(profile.get()))->
5227       CreateExtensionService(
5228           command_line.get(),
5229           install_dir,
5230           false);
5231   EXPECT_FALSE(service->extensions_enabled());
5232   service->Init();
5233   base::RunLoop().RunUntilIdle();
5234   EXPECT_TRUE(recorder.ready());
5235
5236   // Explicitly delete all the resources used in this test.
5237   profile.reset();
5238   service = NULL;
5239   // Execute any pending deletion tasks.
5240   base::RunLoop().RunUntilIdle();
5241 }
5242
5243 // Test loading extensions that require limited and unlimited storage quotas.
5244 TEST_F(ExtensionServiceTest, StorageQuota) {
5245   InitializeEmptyExtensionService();
5246
5247   base::FilePath extensions_path = data_dir().AppendASCII("storage_quota");
5248
5249   base::FilePath limited_quota_ext =
5250       extensions_path.AppendASCII("limited_quota")
5251       .AppendASCII("1.0");
5252
5253   // The old permission name for unlimited quota was "unlimited_storage", but
5254   // we changed it to "unlimitedStorage". This tests both versions.
5255   base::FilePath unlimited_quota_ext =
5256       extensions_path.AppendASCII("unlimited_quota")
5257       .AppendASCII("1.0");
5258   base::FilePath unlimited_quota_ext2 =
5259       extensions_path.AppendASCII("unlimited_quota")
5260       .AppendASCII("2.0");
5261   extensions::UnpackedInstaller::Create(service())->Load(limited_quota_ext);
5262   extensions::UnpackedInstaller::Create(service())->Load(unlimited_quota_ext);
5263   extensions::UnpackedInstaller::Create(service())->Load(unlimited_quota_ext2);
5264   base::RunLoop().RunUntilIdle();
5265
5266   ASSERT_EQ(3u, loaded_.size());
5267   EXPECT_TRUE(profile());
5268   EXPECT_FALSE(profile()->IsOffTheRecord());
5269   EXPECT_FALSE(
5270       profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
5271           loaded_[0]->url()));
5272   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
5273       loaded_[1]->url()));
5274   EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
5275       loaded_[2]->url()));
5276 }
5277
5278 // Tests ComponentLoader::Add().
5279 TEST_F(ExtensionServiceTest, ComponentExtensions) {
5280   InitializeEmptyExtensionService();
5281
5282   // Component extensions should work even when extensions are disabled.
5283   service()->set_extensions_enabled(false);
5284
5285   base::FilePath path = data_dir()
5286                             .AppendASCII("good")
5287                             .AppendASCII("Extensions")
5288                             .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
5289                             .AppendASCII("1.0.0.0");
5290
5291   std::string manifest;
5292   ASSERT_TRUE(base::ReadFileToString(
5293       path.Append(extensions::kManifestFilename), &manifest));
5294
5295   service()->component_loader()->Add(manifest, path);
5296   service()->Init();
5297
5298   // Note that we do not pump messages -- the extension should be loaded
5299   // immediately.
5300
5301   EXPECT_EQ(0u, GetErrors().size());
5302   ASSERT_EQ(1u, loaded_.size());
5303   EXPECT_EQ(Manifest::COMPONENT, loaded_[0]->location());
5304   EXPECT_EQ(1u, registry()->enabled_extensions().size());
5305
5306   // Component extensions get a prefs entry on first install.
5307   ValidatePrefKeyCount(1);
5308
5309   // Reload all extensions, and make sure it comes back.
5310   std::string extension_id = (*registry()->enabled_extensions().begin())->id();
5311   loaded_.clear();
5312   service()->ReloadExtensionsForTest();
5313   ASSERT_EQ(1u, registry()->enabled_extensions().size());
5314   EXPECT_EQ(extension_id, (*registry()->enabled_extensions().begin())->id());
5315 }
5316
5317 TEST_F(ExtensionServiceTest, DeferredSyncStartupPreInstalledComponent) {
5318   InitializeEmptyExtensionService();
5319   InitializeExtensionSyncService();
5320
5321   bool flare_was_called = false;
5322   syncer::ModelType triggered_type(syncer::UNSPECIFIED);
5323   base::WeakPtrFactory<ExtensionServiceTest> factory(this);
5324   extension_sync_service()->SetSyncStartFlare(
5325       base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
5326                  factory.GetWeakPtr(),
5327                  &flare_was_called,  // Safe due to WeakPtrFactory scope.
5328                  &triggered_type));  // Safe due to WeakPtrFactory scope.
5329
5330   // Install a component extension.
5331   std::string manifest;
5332   ASSERT_TRUE(base::ReadFileToString(
5333       good0_path().Append(extensions::kManifestFilename), &manifest));
5334   service()->component_loader()->Add(manifest, good0_path());
5335   ASSERT_FALSE(service()->is_ready());
5336   service()->Init();
5337   ASSERT_TRUE(service()->is_ready());
5338
5339   // Extensions added before service is_ready() don't trigger sync startup.
5340   EXPECT_FALSE(flare_was_called);
5341   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
5342 }
5343
5344 TEST_F(ExtensionServiceTest, DeferredSyncStartupPreInstalledNormal) {
5345   InitializeGoodInstalledExtensionService();
5346   InitializeExtensionSyncService();
5347
5348   bool flare_was_called = false;
5349   syncer::ModelType triggered_type(syncer::UNSPECIFIED);
5350   base::WeakPtrFactory<ExtensionServiceTest> factory(this);
5351   extension_sync_service()->SetSyncStartFlare(
5352       base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
5353                  factory.GetWeakPtr(),
5354                  &flare_was_called,  // Safe due to WeakPtrFactory scope.
5355                  &triggered_type));  // Safe due to WeakPtrFactory scope.
5356
5357   ASSERT_FALSE(service()->is_ready());
5358   service()->Init();
5359   ASSERT_EQ(3u, loaded_.size());
5360   ASSERT_TRUE(service()->is_ready());
5361
5362   // Extensions added before service is_ready() don't trigger sync startup.
5363   EXPECT_FALSE(flare_was_called);
5364   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
5365 }
5366
5367 TEST_F(ExtensionServiceTest, DeferredSyncStartupOnInstall) {
5368   InitializeEmptyExtensionService();
5369   InitializeExtensionSyncService();
5370   service()->Init();
5371   ASSERT_TRUE(service()->is_ready());
5372
5373   bool flare_was_called = false;
5374   syncer::ModelType triggered_type(syncer::UNSPECIFIED);
5375   base::WeakPtrFactory<ExtensionServiceTest> factory(this);
5376   extension_sync_service()->SetSyncStartFlare(
5377       base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
5378                  factory.GetWeakPtr(),
5379                  &flare_was_called,  // Safe due to WeakPtrFactory scope.
5380                  &triggered_type));  // Safe due to WeakPtrFactory scope.
5381
5382   base::FilePath path = data_dir().AppendASCII("good.crx");
5383   InstallCRX(path, INSTALL_NEW);
5384
5385   EXPECT_TRUE(flare_was_called);
5386   EXPECT_EQ(syncer::EXTENSIONS, triggered_type);
5387
5388   // Reset.
5389   flare_was_called = false;
5390   triggered_type = syncer::UNSPECIFIED;
5391
5392   // Once sync starts, flare should no longer be invoked.
5393   extension_sync_service()->MergeDataAndStartSyncing(
5394       syncer::EXTENSIONS,
5395       syncer::SyncDataList(),
5396       scoped_ptr<syncer::SyncChangeProcessor>(
5397           new syncer::FakeSyncChangeProcessor),
5398       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5399   path = data_dir().AppendASCII("page_action.crx");
5400   InstallCRX(path, INSTALL_NEW);
5401   EXPECT_FALSE(flare_was_called);
5402   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
5403 }
5404
5405 TEST_F(ExtensionServiceTest, DisableExtensionFromSync) {
5406   // Start the extensions service with one external extension already installed.
5407   base::FilePath source_install_dir =
5408       data_dir().AppendASCII("good").AppendASCII("Extensions");
5409   base::FilePath pref_path =
5410       source_install_dir.DirName().Append(chrome::kPreferencesFilename);
5411
5412   InitializeInstalledExtensionService(pref_path, source_install_dir);
5413   InitializeExtensionSyncService();
5414
5415   // The user has enabled sync.
5416   ProfileSyncService* sync_service =
5417       ProfileSyncServiceFactory::GetForProfile(profile());
5418   sync_service->SetSyncSetupCompleted();
5419
5420   service()->Init();
5421   ASSERT_TRUE(service()->is_ready());
5422
5423   ASSERT_EQ(3u, loaded_.size());
5424
5425   // We start enabled.
5426   const Extension* extension = service()->GetExtensionById(good0, true);
5427   ASSERT_TRUE(extension);
5428   ASSERT_TRUE(service()->IsExtensionEnabled(good0));
5429   extensions::ExtensionSyncData disable_good_crx(
5430       *extension, false, false, false);
5431
5432   // Then sync data arrives telling us to disable |good0|.
5433   syncer::SyncDataList sync_data;
5434   sync_data.push_back(disable_good_crx.GetSyncData());
5435   extension_sync_service()->MergeDataAndStartSyncing(
5436       syncer::EXTENSIONS,
5437       sync_data,
5438       scoped_ptr<syncer::SyncChangeProcessor>(
5439           new syncer::FakeSyncChangeProcessor),
5440       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5441   ASSERT_FALSE(service()->IsExtensionEnabled(good0));
5442 }
5443
5444 TEST_F(ExtensionServiceTest, DontDisableExtensionWithPendingEnableFromSync) {
5445   // Start the extensions service with one external extension already installed.
5446   base::FilePath source_install_dir =
5447       data_dir().AppendASCII("good").AppendASCII("Extensions");
5448   base::FilePath pref_path =
5449       source_install_dir.DirName().Append(chrome::kPreferencesFilename);
5450
5451   InitializeInstalledExtensionService(pref_path, source_install_dir);
5452   InitializeExtensionSyncService();
5453
5454   // The user has enabled sync.
5455   ProfileSyncService* sync_service =
5456       ProfileSyncServiceFactory::GetForProfile(profile());
5457   sync_service->SetSyncSetupCompleted();
5458
5459   service()->Init();
5460   ASSERT_TRUE(service()->is_ready());
5461   ASSERT_EQ(3u, loaded_.size());
5462
5463   const Extension* extension = service()->GetExtensionById(good0, true);
5464   ASSERT_TRUE(service()->IsExtensionEnabled(good0));
5465
5466   // Disable extension before first sync data arrives.
5467   service()->DisableExtension(good0, Extension::DISABLE_USER_ACTION);
5468   ASSERT_FALSE(service()->IsExtensionEnabled(good0));
5469
5470   // Enable extension - this is now the most recent state.
5471   service()->EnableExtension(good0);
5472   ASSERT_TRUE(service()->IsExtensionEnabled(good0));
5473
5474   // Now sync data comes in that says to disable good0. This should be
5475   // ignored.
5476   extensions::ExtensionSyncData disable_good_crx(
5477       *extension, false, false, false);
5478   syncer::SyncDataList sync_data;
5479   sync_data.push_back(disable_good_crx.GetSyncData());
5480   extension_sync_service()->MergeDataAndStartSyncing(
5481       syncer::EXTENSIONS,
5482       sync_data,
5483       scoped_ptr<syncer::SyncChangeProcessor>(
5484           new syncer::FakeSyncChangeProcessor),
5485       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5486
5487   // The extension was enabled locally before the sync data arrived, so it
5488   // should still be enabled now.
5489   ASSERT_TRUE(service()->IsExtensionEnabled(good0));
5490 }
5491
5492 TEST_F(ExtensionServiceTest, GetSyncData) {
5493   InitializeEmptyExtensionService();
5494   InitializeExtensionSyncService();
5495   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5496   const Extension* extension = service()->GetInstalledExtension(good_crx);
5497   ASSERT_TRUE(extension);
5498
5499   extension_sync_service()->MergeDataAndStartSyncing(
5500       syncer::EXTENSIONS,
5501       syncer::SyncDataList(),
5502       scoped_ptr<syncer::SyncChangeProcessor>(
5503           new syncer::FakeSyncChangeProcessor),
5504       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5505
5506   syncer::SyncDataList list =
5507       extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5508   ASSERT_EQ(list.size(), 1U);
5509   extensions::ExtensionSyncData data(list[0]);
5510   EXPECT_EQ(extension->id(), data.id());
5511   EXPECT_FALSE(data.uninstalled());
5512   EXPECT_EQ(service()->IsExtensionEnabled(good_crx), data.enabled());
5513   EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile()),
5514             data.incognito_enabled());
5515   EXPECT_TRUE(data.version().Equals(*extension->version()));
5516   EXPECT_EQ(extensions::ManifestURL::GetUpdateURL(extension),
5517             data.update_url());
5518   EXPECT_EQ(extension->name(), data.name());
5519 }
5520
5521 TEST_F(ExtensionServiceTest, GetSyncDataTerminated) {
5522   InitializeEmptyExtensionService();
5523   InitializeExtensionSyncService();
5524   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5525   TerminateExtension(good_crx);
5526   const Extension* extension = service()->GetInstalledExtension(good_crx);
5527   ASSERT_TRUE(extension);
5528
5529   syncer::FakeSyncChangeProcessor processor;
5530   extension_sync_service()->MergeDataAndStartSyncing(
5531       syncer::EXTENSIONS,
5532       syncer::SyncDataList(),
5533       scoped_ptr<syncer::SyncChangeProcessor>(
5534           new syncer::FakeSyncChangeProcessor),
5535       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5536
5537   syncer::SyncDataList list =
5538       extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5539   ASSERT_EQ(list.size(), 1U);
5540   extensions::ExtensionSyncData data(list[0]);
5541   EXPECT_EQ(extension->id(), data.id());
5542   EXPECT_FALSE(data.uninstalled());
5543   EXPECT_EQ(service()->IsExtensionEnabled(good_crx), data.enabled());
5544   EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile()),
5545             data.incognito_enabled());
5546   EXPECT_TRUE(data.version().Equals(*extension->version()));
5547   EXPECT_EQ(extensions::ManifestURL::GetUpdateURL(extension),
5548             data.update_url());
5549   EXPECT_EQ(extension->name(), data.name());
5550 }
5551
5552 TEST_F(ExtensionServiceTest, GetSyncDataFilter) {
5553   InitializeEmptyExtensionService();
5554   InitializeExtensionSyncService();
5555   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5556   const Extension* extension = service()->GetInstalledExtension(good_crx);
5557   ASSERT_TRUE(extension);
5558
5559   syncer::FakeSyncChangeProcessor processor;
5560   extension_sync_service()->MergeDataAndStartSyncing(
5561       syncer::APPS,
5562       syncer::SyncDataList(),
5563       scoped_ptr<syncer::SyncChangeProcessor>(
5564           new syncer::FakeSyncChangeProcessor),
5565       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5566
5567   syncer::SyncDataList list =
5568       extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5569   ASSERT_EQ(list.size(), 0U);
5570 }
5571
5572 TEST_F(ExtensionServiceTest, GetSyncExtensionDataUserSettings) {
5573   InitializeEmptyExtensionService();
5574   InitializeProcessManager();
5575   InitializeExtensionSyncService();
5576   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5577   const Extension* extension = service()->GetInstalledExtension(good_crx);
5578   ASSERT_TRUE(extension);
5579
5580   syncer::FakeSyncChangeProcessor processor;
5581   extension_sync_service()->MergeDataAndStartSyncing(
5582       syncer::EXTENSIONS,
5583       syncer::SyncDataList(),
5584       scoped_ptr<syncer::SyncChangeProcessor>(
5585           new syncer::FakeSyncChangeProcessor),
5586       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5587
5588   {
5589     syncer::SyncDataList list =
5590         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5591     ASSERT_EQ(list.size(), 1U);
5592     extensions::ExtensionSyncData data(list[0]);
5593     EXPECT_TRUE(data.enabled());
5594     EXPECT_FALSE(data.incognito_enabled());
5595   }
5596
5597   service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
5598   {
5599     syncer::SyncDataList list =
5600         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5601     ASSERT_EQ(list.size(), 1U);
5602     extensions::ExtensionSyncData data(list[0]);
5603     EXPECT_FALSE(data.enabled());
5604     EXPECT_FALSE(data.incognito_enabled());
5605   }
5606
5607   extensions::util::SetIsIncognitoEnabled(good_crx, profile(), true);
5608   {
5609     syncer::SyncDataList list =
5610         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5611     ASSERT_EQ(list.size(), 1U);
5612     extensions::ExtensionSyncData data(list[0]);
5613     EXPECT_FALSE(data.enabled());
5614     EXPECT_TRUE(data.incognito_enabled());
5615   }
5616
5617   service()->EnableExtension(good_crx);
5618   {
5619     syncer::SyncDataList list =
5620         extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
5621     ASSERT_EQ(list.size(), 1U);
5622     extensions::ExtensionSyncData data(list[0]);
5623     EXPECT_TRUE(data.enabled());
5624     EXPECT_TRUE(data.incognito_enabled());
5625   }
5626 }
5627
5628 TEST_F(ExtensionServiceTest, SyncForUninstalledExternalExtension) {
5629   InitializeEmptyExtensionService();
5630   InitializeExtensionSyncService();
5631   InstallCRXWithLocation(
5632       data_dir().AppendASCII("good.crx"), Manifest::EXTERNAL_PREF, INSTALL_NEW);
5633   const Extension* extension = service()->GetInstalledExtension(good_crx);
5634   ASSERT_TRUE(extension);
5635
5636   syncer::FakeSyncChangeProcessor processor;
5637   extension_sync_service()->MergeDataAndStartSyncing(
5638       syncer::EXTENSIONS,
5639       syncer::SyncDataList(),
5640       scoped_ptr<syncer::SyncChangeProcessor>(
5641           new syncer::FakeSyncChangeProcessor),
5642       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5643
5644   UninstallExtension(good_crx, false);
5645   EXPECT_TRUE(
5646       ExtensionPrefs::Get(profile())->IsExternalExtensionUninstalled(good_crx));
5647
5648   sync_pb::EntitySpecifics specifics;
5649   sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
5650   sync_pb::ExtensionSpecifics* extension_specifics =
5651       app_specifics->mutable_extension();
5652   extension_specifics->set_id(good_crx);
5653   extension_specifics->set_version("1.0");
5654   extension_specifics->set_enabled(true);
5655
5656   syncer::SyncData sync_data =
5657       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5658   syncer::SyncChange sync_change(FROM_HERE,
5659                                  syncer::SyncChange::ACTION_UPDATE,
5660                                  sync_data);
5661   syncer::SyncChangeList list(1);
5662   list[0] = sync_change;
5663
5664   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5665   EXPECT_TRUE(
5666       ExtensionPrefs::Get(profile())->IsExternalExtensionUninstalled(good_crx));
5667 }
5668
5669 TEST_F(ExtensionServiceTest, GetSyncAppDataUserSettings) {
5670   InitializeEmptyExtensionService();
5671   InitializeExtensionSyncService();
5672   const Extension* app =
5673       PackAndInstallCRX(data_dir().AppendASCII("app"), INSTALL_NEW);
5674   ASSERT_TRUE(app);
5675   ASSERT_TRUE(app->is_app());
5676
5677   syncer::FakeSyncChangeProcessor processor;
5678   extension_sync_service()->MergeDataAndStartSyncing(
5679       syncer::APPS,
5680       syncer::SyncDataList(),
5681       scoped_ptr<syncer::SyncChangeProcessor>(
5682           new syncer::FakeSyncChangeProcessor),
5683       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5684
5685   syncer::StringOrdinal initial_ordinal =
5686       syncer::StringOrdinal::CreateInitialOrdinal();
5687   {
5688     syncer::SyncDataList list =
5689         extension_sync_service()->GetAllSyncData(syncer::APPS);
5690     ASSERT_EQ(list.size(), 1U);
5691
5692     extensions::AppSyncData app_sync_data(list[0]);
5693     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.app_launch_ordinal()));
5694     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
5695   }
5696
5697   AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
5698   sorting->SetAppLaunchOrdinal(app->id(), initial_ordinal.CreateAfter());
5699   {
5700     syncer::SyncDataList list =
5701         extension_sync_service()->GetAllSyncData(syncer::APPS);
5702     ASSERT_EQ(list.size(), 1U);
5703
5704     extensions::AppSyncData app_sync_data(list[0]);
5705     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
5706     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
5707   }
5708
5709   sorting->SetPageOrdinal(app->id(), initial_ordinal.CreateAfter());
5710   {
5711     syncer::SyncDataList list =
5712         extension_sync_service()->GetAllSyncData(syncer::APPS);
5713     ASSERT_EQ(list.size(), 1U);
5714
5715     extensions::AppSyncData app_sync_data(list[0]);
5716     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
5717     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.page_ordinal()));
5718   }
5719 }
5720
5721 // TODO (rdevlin.cronin): The OnExtensionMoved() method has been removed from
5722 // ExtensionService, so this test probably needs a new home. Unfortunately, it
5723 // relies pretty heavily on things like InitializeExtension[Sync]Service() and
5724 // PackAndInstallCRX(). When we clean up a bit more, this should move out.
5725 TEST_F(ExtensionServiceTest, GetSyncAppDataUserSettingsOnExtensionMoved) {
5726   InitializeEmptyExtensionService();
5727   InitializeExtensionSyncService();
5728   const size_t kAppCount = 3;
5729   const Extension* apps[kAppCount];
5730   apps[0] = PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
5731   apps[1] = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
5732   apps[2] = PackAndInstallCRX(data_dir().AppendASCII("app4"), INSTALL_NEW);
5733   for (size_t i = 0; i < kAppCount; ++i) {
5734     ASSERT_TRUE(apps[i]);
5735     ASSERT_TRUE(apps[i]->is_app());
5736   }
5737
5738   syncer::FakeSyncChangeProcessor processor;
5739   extension_sync_service()->MergeDataAndStartSyncing(
5740       syncer::APPS,
5741       syncer::SyncDataList(),
5742       scoped_ptr<syncer::SyncChangeProcessor>(
5743           new syncer::FakeSyncChangeProcessor),
5744       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5745
5746   ExtensionPrefs::Get(service()->GetBrowserContext())
5747       ->app_sorting()
5748       ->OnExtensionMoved(apps[0]->id(), apps[1]->id(), apps[2]->id());
5749   {
5750     syncer::SyncDataList list =
5751         extension_sync_service()->GetAllSyncData(syncer::APPS);
5752     ASSERT_EQ(list.size(), 3U);
5753
5754     extensions::AppSyncData data[kAppCount];
5755     for (size_t i = 0; i < kAppCount; ++i) {
5756       data[i] = extensions::AppSyncData(list[i]);
5757     }
5758
5759     // The sync data is not always in the same order our apps were installed in,
5760     // so we do that sorting here so we can make sure the values are changed as
5761     // expected.
5762     syncer::StringOrdinal app_launch_ordinals[kAppCount];
5763     for (size_t i = 0; i < kAppCount; ++i) {
5764       for (size_t j = 0; j < kAppCount; ++j) {
5765         if (apps[i]->id() == data[j].id())
5766           app_launch_ordinals[i] = data[j].app_launch_ordinal();
5767       }
5768     }
5769
5770     EXPECT_TRUE(app_launch_ordinals[1].LessThan(app_launch_ordinals[0]));
5771     EXPECT_TRUE(app_launch_ordinals[0].LessThan(app_launch_ordinals[2]));
5772   }
5773 }
5774
5775 TEST_F(ExtensionServiceTest, GetSyncDataList) {
5776   InitializeEmptyExtensionService();
5777   InitializeExtensionSyncService();
5778   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5779   InstallCRX(data_dir().AppendASCII("page_action.crx"), INSTALL_NEW);
5780   InstallCRX(data_dir().AppendASCII("theme.crx"), INSTALL_NEW);
5781   InstallCRX(data_dir().AppendASCII("theme2.crx"), INSTALL_NEW);
5782
5783   syncer::FakeSyncChangeProcessor processor;
5784   extension_sync_service()->MergeDataAndStartSyncing(
5785       syncer::APPS,
5786       syncer::SyncDataList(),
5787       scoped_ptr<syncer::SyncChangeProcessor>(
5788           new syncer::FakeSyncChangeProcessor),
5789       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5790   extension_sync_service()->MergeDataAndStartSyncing(
5791       syncer::EXTENSIONS,
5792       syncer::SyncDataList(),
5793       scoped_ptr<syncer::SyncChangeProcessor>(
5794           new syncer::FakeSyncChangeProcessor),
5795       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5796
5797   service()->DisableExtension(page_action, Extension::DISABLE_USER_ACTION);
5798   TerminateExtension(theme2_crx);
5799
5800   EXPECT_EQ(0u, extension_sync_service()->GetAllSyncData(syncer::APPS).size());
5801   EXPECT_EQ(
5802       2u, extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS).size());
5803 }
5804
5805 TEST_F(ExtensionServiceTest, ProcessSyncDataUninstall) {
5806   InitializeEmptyExtensionService();
5807   InitializeExtensionSyncService();
5808   syncer::FakeSyncChangeProcessor processor;
5809   extension_sync_service()->MergeDataAndStartSyncing(
5810       syncer::EXTENSIONS,
5811       syncer::SyncDataList(),
5812       scoped_ptr<syncer::SyncChangeProcessor>(
5813           new syncer::FakeSyncChangeProcessor),
5814       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5815
5816   sync_pb::EntitySpecifics specifics;
5817   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
5818   ext_specifics->set_id(good_crx);
5819   ext_specifics->set_version("1.0");
5820   syncer::SyncData sync_data =
5821       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5822   syncer::SyncChange sync_change(FROM_HERE,
5823                                  syncer::SyncChange::ACTION_DELETE,
5824                                  sync_data);
5825   syncer::SyncChangeList list(1);
5826   list[0] = sync_change;
5827
5828   // Should do nothing.
5829   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5830   EXPECT_FALSE(service()->GetExtensionById(good_crx, true));
5831
5832   // Install the extension.
5833   base::FilePath extension_path = data_dir().AppendASCII("good.crx");
5834   InstallCRX(extension_path, INSTALL_NEW);
5835   EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
5836
5837   // Should uninstall the extension.
5838   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5839   EXPECT_FALSE(service()->GetExtensionById(good_crx, true));
5840
5841   // Should again do nothing.
5842   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5843   EXPECT_FALSE(service()->GetExtensionById(good_crx, true));
5844 }
5845
5846 TEST_F(ExtensionServiceTest, ProcessSyncDataWrongType) {
5847   InitializeEmptyExtensionService();
5848   InitializeExtensionSyncService();
5849
5850   // Install the extension.
5851   base::FilePath extension_path = data_dir().AppendASCII("good.crx");
5852   InstallCRX(extension_path, INSTALL_NEW);
5853   EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
5854
5855   sync_pb::EntitySpecifics specifics;
5856   sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
5857   sync_pb::ExtensionSpecifics* extension_specifics =
5858       app_specifics->mutable_extension();
5859   extension_specifics->set_id(good_crx);
5860   extension_specifics->set_version(
5861       service()->GetInstalledExtension(good_crx)->version()->GetString());
5862
5863   {
5864     extension_specifics->set_enabled(true);
5865     syncer::SyncData sync_data =
5866         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5867     syncer::SyncChange sync_change(FROM_HERE,
5868                                    syncer::SyncChange::ACTION_DELETE,
5869                                    sync_data);
5870     syncer::SyncChangeList list(1);
5871     list[0] = sync_change;
5872
5873     // Should do nothing
5874     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5875     EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
5876   }
5877
5878   {
5879     extension_specifics->set_enabled(false);
5880     syncer::SyncData sync_data =
5881         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5882     syncer::SyncChange sync_change(FROM_HERE,
5883                                    syncer::SyncChange::ACTION_UPDATE,
5884                                    sync_data);
5885     syncer::SyncChangeList list(1);
5886     list[0] = sync_change;
5887
5888     // Should again do nothing.
5889     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5890     EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
5891   }
5892 }
5893
5894 TEST_F(ExtensionServiceTest, ProcessSyncDataSettings) {
5895   InitializeEmptyExtensionService();
5896   InitializeProcessManager();
5897   InitializeExtensionSyncService();
5898   syncer::FakeSyncChangeProcessor processor;
5899   extension_sync_service()->MergeDataAndStartSyncing(
5900       syncer::EXTENSIONS,
5901       syncer::SyncDataList(),
5902       scoped_ptr<syncer::SyncChangeProcessor>(
5903           new syncer::FakeSyncChangeProcessor),
5904       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5905
5906   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5907   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
5908   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
5909
5910   sync_pb::EntitySpecifics specifics;
5911   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
5912   ext_specifics->set_id(good_crx);
5913   ext_specifics->set_version(
5914       service()->GetInstalledExtension(good_crx)->version()->GetString());
5915   ext_specifics->set_enabled(false);
5916
5917   {
5918     syncer::SyncData sync_data =
5919         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5920     syncer::SyncChange sync_change(FROM_HERE,
5921                                    syncer::SyncChange::ACTION_UPDATE,
5922                                    sync_data);
5923     syncer::SyncChangeList list(1);
5924     list[0] = sync_change;
5925     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5926     EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
5927     EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
5928   }
5929
5930   {
5931     ext_specifics->set_enabled(true);
5932     ext_specifics->set_incognito_enabled(true);
5933     syncer::SyncData sync_data =
5934         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5935     syncer::SyncChange sync_change(FROM_HERE,
5936                                    syncer::SyncChange::ACTION_UPDATE,
5937                                    sync_data);
5938     syncer::SyncChangeList list(1);
5939     list[0] = sync_change;
5940     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5941     EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
5942     EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
5943   }
5944
5945   {
5946     ext_specifics->set_enabled(false);
5947     ext_specifics->set_incognito_enabled(true);
5948     syncer::SyncData sync_data =
5949         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5950     syncer::SyncChange sync_change(FROM_HERE,
5951                                    syncer::SyncChange::ACTION_UPDATE,
5952                                    sync_data);
5953     syncer::SyncChangeList list(1);
5954     list[0] = sync_change;
5955     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5956     EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
5957     EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
5958   }
5959
5960   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
5961 }
5962
5963 TEST_F(ExtensionServiceTest, ProcessSyncDataTerminatedExtension) {
5964   InitializeExtensionServiceWithUpdater();
5965   InitializeExtensionSyncService();
5966   syncer::FakeSyncChangeProcessor processor;
5967   extension_sync_service()->MergeDataAndStartSyncing(
5968       syncer::EXTENSIONS,
5969       syncer::SyncDataList(),
5970       scoped_ptr<syncer::SyncChangeProcessor>(
5971           new syncer::FakeSyncChangeProcessor),
5972       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
5973
5974   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
5975   TerminateExtension(good_crx);
5976   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
5977   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
5978
5979   sync_pb::EntitySpecifics specifics;
5980   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
5981   ext_specifics->set_id(good_crx);
5982   ext_specifics->set_version(
5983       service()->GetInstalledExtension(good_crx)->version()->GetString());
5984   ext_specifics->set_enabled(false);
5985   ext_specifics->set_incognito_enabled(true);
5986   syncer::SyncData sync_data =
5987       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
5988   syncer::SyncChange sync_change(FROM_HERE,
5989                                  syncer::SyncChange::ACTION_UPDATE,
5990                                  sync_data);
5991   syncer::SyncChangeList list(1);
5992   list[0] = sync_change;
5993
5994   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
5995   EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
5996   EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
5997
5998   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
5999 }
6000
6001 TEST_F(ExtensionServiceTest, ProcessSyncDataVersionCheck) {
6002   InitializeExtensionServiceWithUpdater();
6003   InitializeExtensionSyncService();
6004   syncer::FakeSyncChangeProcessor processor;
6005   extension_sync_service()->MergeDataAndStartSyncing(
6006       syncer::EXTENSIONS,
6007       syncer::SyncDataList(),
6008       scoped_ptr<syncer::SyncChangeProcessor>(
6009           new syncer::FakeSyncChangeProcessor),
6010       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
6011
6012   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
6013   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
6014   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
6015
6016   sync_pb::EntitySpecifics specifics;
6017   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
6018   ext_specifics->set_id(good_crx);
6019   ext_specifics->set_enabled(true);
6020
6021   {
6022     ext_specifics->set_version(
6023         service()->GetInstalledExtension(good_crx)->version()->GetString());
6024     syncer::SyncData sync_data =
6025         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
6026     syncer::SyncChange sync_change(FROM_HERE,
6027                                    syncer::SyncChange::ACTION_UPDATE,
6028                                    sync_data);
6029     syncer::SyncChangeList list(1);
6030     list[0] = sync_change;
6031
6032     // Should do nothing if extension version == sync version.
6033     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
6034     EXPECT_FALSE(service()->updater()->WillCheckSoon());
6035   }
6036
6037   // Should do nothing if extension version > sync version (but see
6038   // the TODO in ProcessExtensionSyncData).
6039   {
6040     ext_specifics->set_version("0.0.0.0");
6041     syncer::SyncData sync_data =
6042         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
6043     syncer::SyncChange sync_change(FROM_HERE,
6044                                    syncer::SyncChange::ACTION_UPDATE,
6045                                    sync_data);
6046     syncer::SyncChangeList list(1);
6047     list[0] = sync_change;
6048
6049     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
6050     EXPECT_FALSE(service()->updater()->WillCheckSoon());
6051   }
6052
6053   // Should kick off an update if extension version < sync version.
6054   {
6055     ext_specifics->set_version("9.9.9.9");
6056     syncer::SyncData sync_data =
6057         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
6058     syncer::SyncChange sync_change(FROM_HERE,
6059                                    syncer::SyncChange::ACTION_UPDATE,
6060                                    sync_data);
6061     syncer::SyncChangeList list(1);
6062     list[0] = sync_change;
6063
6064     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
6065     EXPECT_TRUE(service()->updater()->WillCheckSoon());
6066   }
6067
6068   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
6069 }
6070
6071 TEST_F(ExtensionServiceTest, ProcessSyncDataNotInstalled) {
6072   InitializeExtensionServiceWithUpdater();
6073   InitializeExtensionSyncService();
6074   syncer::FakeSyncChangeProcessor processor;
6075   extension_sync_service()->MergeDataAndStartSyncing(
6076       syncer::EXTENSIONS,
6077       syncer::SyncDataList(),
6078       scoped_ptr<syncer::SyncChangeProcessor>(
6079           new syncer::FakeSyncChangeProcessor),
6080       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
6081
6082   sync_pb::EntitySpecifics specifics;
6083   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
6084   ext_specifics->set_id(good_crx);
6085   ext_specifics->set_enabled(false);
6086   ext_specifics->set_incognito_enabled(true);
6087   ext_specifics->set_update_url("http://www.google.com/");
6088   ext_specifics->set_version("1.2.3.4");
6089   syncer::SyncData sync_data =
6090       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
6091   syncer::SyncChange sync_change(FROM_HERE,
6092                                  syncer::SyncChange::ACTION_UPDATE,
6093                                  sync_data);
6094   syncer::SyncChangeList list(1);
6095   list[0] = sync_change;
6096
6097   EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
6098   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
6099   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
6100   EXPECT_TRUE(service()->updater()->WillCheckSoon());
6101   EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
6102   EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
6103
6104   const extensions::PendingExtensionInfo* info;
6105   EXPECT_TRUE(
6106       (info = service()->pending_extension_manager()->GetById(good_crx)));
6107   EXPECT_EQ(ext_specifics->update_url(), info->update_url().spec());
6108   EXPECT_TRUE(info->is_from_sync());
6109   EXPECT_TRUE(info->install_silently());
6110   EXPECT_EQ(Manifest::INTERNAL, info->install_source());
6111   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
6112 }
6113
6114 TEST_F(ExtensionServiceTest, SupervisedUser_InstallOnlyAllowedByCustodian) {
6115   ExtensionServiceInitParams params = CreateDefaultInitParams();
6116   params.profile_is_supervised = true;
6117   InitializeExtensionService(params);
6118
6119   SupervisedUserService* supervised_user_service =
6120       SupervisedUserServiceFactory::GetForProfile(profile());
6121   GetManagementPolicy()->RegisterProvider(supervised_user_service);
6122
6123   base::FilePath path1 = data_dir().AppendASCII("good.crx");
6124   base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
6125   const Extension* extensions[] = {
6126     InstallCRX(path1, INSTALL_FAILED),
6127     InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
6128   };
6129
6130   // Only the extension with the "installed by custodian" flag should have been
6131   // installed and enabled.
6132   EXPECT_FALSE(extensions[0]);
6133   ASSERT_TRUE(extensions[1]);
6134   EXPECT_TRUE(registry()->enabled_extensions().Contains(extensions[1]->id()));
6135 }
6136
6137 TEST_F(ExtensionServiceTest, SupervisedUser_UpdateWithoutPermissionIncrease) {
6138   ExtensionServiceInitParams params = CreateDefaultInitParams();
6139   params.profile_is_supervised = true;
6140   InitializeExtensionService(params);
6141
6142   SupervisedUserService* supervised_user_service =
6143       SupervisedUserServiceFactory::GetForProfile(profile());
6144   GetManagementPolicy()->RegisterProvider(supervised_user_service);
6145
6146   base::FilePath base_path = data_dir().AppendASCII("autoupdate");
6147   base::FilePath pem_path = base_path.AppendASCII("key.pem");
6148
6149   base::FilePath path = base_path.AppendASCII("v1");
6150   const Extension* extension =
6151       PackAndInstallCRX(path, pem_path, INSTALL_NEW,
6152                         Extension::WAS_INSTALLED_BY_CUSTODIAN);
6153   // The extension must now be installed and enabled.
6154   ASSERT_TRUE(extension);
6155   ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
6156
6157   // Save the id, as the extension object will be destroyed during updating.
6158   std::string id = extension->id();
6159
6160   std::string old_version = extension->VersionString();
6161
6162   // Update to a new version.
6163   path = base_path.AppendASCII("v2");
6164   PackCRXAndUpdateExtension(id, path, pem_path, ENABLED);
6165
6166   // The extension should still be there and enabled.
6167   extension = registry()->enabled_extensions().GetByID(id);
6168   ASSERT_TRUE(extension);
6169   // The version should have changed.
6170   EXPECT_NE(extension->VersionString(), old_version);
6171 }
6172
6173 TEST_F(ExtensionServiceTest, SupervisedUser_UpdateWithPermissionIncrease) {
6174   ExtensionServiceInitParams params = CreateDefaultInitParams();
6175   params.profile_is_supervised = true;
6176   InitializeExtensionService(params);
6177
6178   SupervisedUserService* supervised_user_service =
6179       SupervisedUserServiceFactory::GetForProfile(profile());
6180   GetManagementPolicy()->RegisterProvider(supervised_user_service);
6181
6182   base::FilePath base_path = data_dir().AppendASCII("permissions_increase");
6183   base::FilePath pem_path = base_path.AppendASCII("permissions.pem");
6184
6185   base::FilePath path = base_path.AppendASCII("v1");
6186   const Extension* extension =
6187       PackAndInstallCRX(path, pem_path, INSTALL_NEW,
6188                         Extension::WAS_INSTALLED_BY_CUSTODIAN);
6189   // The extension must now be installed and enabled.
6190   ASSERT_TRUE(extension);
6191   ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
6192
6193   // Save the id, as the extension object will be destroyed during updating.
6194   std::string id = extension->id();
6195
6196   std::string old_version = extension->VersionString();
6197
6198   // Update to a new version with increased permissions.
6199   path = base_path.AppendASCII("v2");
6200   PackCRXAndUpdateExtension(id, path, pem_path, DISABLED);
6201
6202   // The extension should still be there, but disabled.
6203   EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
6204   extension = registry()->disabled_extensions().GetByID(id);
6205   ASSERT_TRUE(extension);
6206   // The version should have changed.
6207   EXPECT_NE(extension->VersionString(), old_version);
6208 }
6209
6210 TEST_F(ExtensionServiceTest,
6211        SupervisedUser_SyncUninstallByCustodianSkipsPolicy) {
6212   InitializeEmptyExtensionService();
6213   InitializeExtensionSyncService();
6214   extension_sync_service()->MergeDataAndStartSyncing(
6215       syncer::EXTENSIONS,
6216       syncer::SyncDataList(),
6217       scoped_ptr<syncer::SyncChangeProcessor>(
6218           new syncer::FakeSyncChangeProcessor),
6219       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
6220
6221   // Install two extensions.
6222   base::FilePath path1 = data_dir().AppendASCII("good.crx");
6223   base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
6224   const Extension* extensions[] = {
6225     InstallCRX(path1, INSTALL_NEW),
6226     InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
6227   };
6228
6229   // Add a policy provider that will disallow any changes.
6230   extensions::TestManagementPolicyProvider provider(
6231       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
6232   GetManagementPolicy()->RegisterProvider(&provider);
6233
6234   // Create a sync deletion for each extension.
6235   syncer::SyncChangeList change_list;
6236   for (size_t i = 0; i < arraysize(extensions); i++) {
6237     const std::string& id = extensions[i]->id();
6238     sync_pb::EntitySpecifics specifics;
6239     sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
6240     ext_specifics->set_id(id);
6241     ext_specifics->set_version("1.0");
6242     ext_specifics->set_installed_by_custodian(
6243         extensions[i]->was_installed_by_custodian());
6244     syncer::SyncData sync_data =
6245         syncer::SyncData::CreateLocalData(id, "Name", specifics);
6246     change_list.push_back(syncer::SyncChange(FROM_HERE,
6247                                              syncer::SyncChange::ACTION_DELETE,
6248                                              sync_data));
6249   }
6250
6251   // Save the extension ids, as uninstalling destroys the Extension instance.
6252   std::string extension_ids[] = {
6253     extensions[0]->id(),
6254     extensions[1]->id()
6255   };
6256
6257   // Now apply the uninstallations.
6258   extension_sync_service()->ProcessSyncChanges(FROM_HERE, change_list);
6259
6260   // Uninstalling the extension without installed_by_custodian should have been
6261   // blocked by policy, so it should still be there.
6262   EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_ids[0]));
6263
6264   // But installed_by_custodian should result in bypassing the policy check.
6265   EXPECT_FALSE(
6266       registry()->GenerateInstalledExtensionsSet()->Contains(extension_ids[1]));
6267 }
6268
6269 TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) {
6270   InitializeEmptyExtensionService();
6271
6272   base::FilePath path = data_dir().AppendASCII("good.crx");
6273   InstallCRX(path, INSTALL_NEW);
6274   ValidatePrefKeyCount(1u);
6275   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
6276   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
6277
6278   extensions::PendingExtensionManager* pending =
6279       service()->pending_extension_manager();
6280   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6281
6282   // Skip install when the location is the same.
6283   EXPECT_FALSE(
6284       service()->OnExternalExtensionUpdateUrlFound(kGoodId,
6285                                                    std::string(),
6286                                                    GURL(kGoodUpdateURL),
6287                                                    Manifest::INTERNAL,
6288                                                    Extension::NO_FLAGS,
6289                                                    false));
6290   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6291
6292   // Install when the location has higher priority.
6293   EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
6294       kGoodId,
6295       std::string(),
6296       GURL(kGoodUpdateURL),
6297       Manifest::EXTERNAL_POLICY_DOWNLOAD,
6298       Extension::NO_FLAGS,
6299       false));
6300   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6301
6302   // Try the low priority again.  Should be rejected.
6303   EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(
6304       kGoodId,
6305       std::string(),
6306       GURL(kGoodUpdateURL),
6307       Manifest::EXTERNAL_PREF_DOWNLOAD,
6308       Extension::NO_FLAGS,
6309       false));
6310   // The existing record should still be present in the pending extension
6311   // manager.
6312   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6313
6314   pending->Remove(kGoodId);
6315
6316   // Skip install when the location has the same priority as the installed
6317   // location.
6318   EXPECT_FALSE(
6319       service()->OnExternalExtensionUpdateUrlFound(kGoodId,
6320                                                    std::string(),
6321                                                    GURL(kGoodUpdateURL),
6322                                                    Manifest::INTERNAL,
6323                                                    Extension::NO_FLAGS,
6324                                                    false));
6325
6326   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6327 }
6328
6329 TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) {
6330   Version older_version("0.1.0.0");
6331   Version newer_version("2.0.0.0");
6332
6333   // We don't want the extension to be installed.  A path that doesn't
6334   // point to a valid CRX ensures this.
6335   const base::FilePath kInvalidPathToCrx = base::FilePath();
6336
6337   const int kCreationFlags = 0;
6338   const bool kDontMarkAcknowledged = false;
6339
6340   InitializeEmptyExtensionService();
6341
6342   // The test below uses install source constants to test that
6343   // priority is enforced.  It assumes a specific ranking of install
6344   // sources: Registry (EXTERNAL_REGISTRY) overrides external pref
6345   // (EXTERNAL_PREF), and external pref overrides user install (INTERNAL).
6346   // The following assertions verify these assumptions:
6347   ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
6348             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
6349                                                  Manifest::EXTERNAL_PREF));
6350   ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
6351             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
6352                                                  Manifest::INTERNAL));
6353   ASSERT_EQ(Manifest::EXTERNAL_PREF,
6354             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_PREF,
6355                                                  Manifest::INTERNAL));
6356
6357   extensions::PendingExtensionManager* pending =
6358       service()->pending_extension_manager();
6359   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6360
6361   {
6362     // Simulate an external source adding the extension as INTERNAL.
6363     content::WindowedNotificationObserver observer(
6364         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6365         content::NotificationService::AllSources());
6366     EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
6367                                                         &older_version,
6368                                                         kInvalidPathToCrx,
6369                                                         Manifest::INTERNAL,
6370                                                         kCreationFlags,
6371                                                         kDontMarkAcknowledged));
6372     EXPECT_TRUE(pending->IsIdPending(kGoodId));
6373     observer.Wait();
6374     VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
6375   }
6376
6377   {
6378     // Simulate an external source adding the extension as EXTERNAL_PREF.
6379     content::WindowedNotificationObserver observer(
6380         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6381         content::NotificationService::AllSources());
6382     EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
6383                                                         &older_version,
6384                                                         kInvalidPathToCrx,
6385                                                         Manifest::EXTERNAL_PREF,
6386                                                         kCreationFlags,
6387                                                         kDontMarkAcknowledged));
6388     EXPECT_TRUE(pending->IsIdPending(kGoodId));
6389     observer.Wait();
6390     VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
6391   }
6392
6393   // Simulate an external source adding as EXTERNAL_PREF again.
6394   // This is rejected because the version and the location are the same as
6395   // the previous installation, which is still pending.
6396   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6397                                                        &older_version,
6398                                                        kInvalidPathToCrx,
6399                                                        Manifest::EXTERNAL_PREF,
6400                                                        kCreationFlags,
6401                                                        kDontMarkAcknowledged));
6402   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6403
6404   // Try INTERNAL again.  Should fail.
6405   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6406                                                        &older_version,
6407                                                        kInvalidPathToCrx,
6408                                                        Manifest::INTERNAL,
6409                                                        kCreationFlags,
6410                                                        kDontMarkAcknowledged));
6411   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6412
6413   {
6414     // Now the registry adds the extension.
6415     content::WindowedNotificationObserver observer(
6416         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6417         content::NotificationService::AllSources());
6418     EXPECT_TRUE(
6419         service()->OnExternalExtensionFileFound(kGoodId,
6420                                                 &older_version,
6421                                                 kInvalidPathToCrx,
6422                                                 Manifest::EXTERNAL_REGISTRY,
6423                                                 kCreationFlags,
6424                                                 kDontMarkAcknowledged));
6425     EXPECT_TRUE(pending->IsIdPending(kGoodId));
6426     observer.Wait();
6427     VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
6428   }
6429
6430   // Registry outranks both external pref and internal, so both fail.
6431   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6432                                                        &older_version,
6433                                                        kInvalidPathToCrx,
6434                                                        Manifest::EXTERNAL_PREF,
6435                                                        kCreationFlags,
6436                                                        kDontMarkAcknowledged));
6437   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6438
6439   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6440                                                        &older_version,
6441                                                        kInvalidPathToCrx,
6442                                                        Manifest::INTERNAL,
6443                                                        kCreationFlags,
6444                                                        kDontMarkAcknowledged));
6445   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6446
6447   pending->Remove(kGoodId);
6448
6449   // Install the extension.
6450   base::FilePath path = data_dir().AppendASCII("good.crx");
6451   const Extension* ext = InstallCRX(path, INSTALL_NEW);
6452   ValidatePrefKeyCount(1u);
6453   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
6454   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
6455
6456   // Now test the logic of OnExternalExtensionFileFound() when the extension
6457   // being added is already installed.
6458
6459   // Tests assume |older_version| is less than the installed version, and
6460   // |newer_version| is greater.  Verify this:
6461   ASSERT_TRUE(older_version.IsOlderThan(ext->VersionString()));
6462   ASSERT_TRUE(ext->version()->IsOlderThan(newer_version.GetString()));
6463
6464   // An external install for the same location should fail if the version is
6465   // older, or the same, and succeed if the version is newer.
6466
6467   // Older than the installed version...
6468   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6469                                                        &older_version,
6470                                                        kInvalidPathToCrx,
6471                                                        Manifest::INTERNAL,
6472                                                        kCreationFlags,
6473                                                        kDontMarkAcknowledged));
6474   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6475
6476   // Same version as the installed version...
6477   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6478                                                        ext->version(),
6479                                                        kInvalidPathToCrx,
6480                                                        Manifest::INTERNAL,
6481                                                        kCreationFlags,
6482                                                        kDontMarkAcknowledged));
6483   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6484
6485   // Newer than the installed version...
6486   EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
6487                                                       &newer_version,
6488                                                       kInvalidPathToCrx,
6489                                                       Manifest::INTERNAL,
6490                                                       kCreationFlags,
6491                                                       kDontMarkAcknowledged));
6492   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6493
6494   // An external install for a higher priority install source should succeed
6495   // if the version is greater.  |older_version| is not...
6496   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6497                                                        &older_version,
6498                                                        kInvalidPathToCrx,
6499                                                        Manifest::EXTERNAL_PREF,
6500                                                        kCreationFlags,
6501                                                        kDontMarkAcknowledged));
6502   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6503
6504   // |newer_version| is newer.
6505   EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
6506                                                       &newer_version,
6507                                                       kInvalidPathToCrx,
6508                                                       Manifest::EXTERNAL_PREF,
6509                                                       kCreationFlags,
6510                                                       kDontMarkAcknowledged));
6511   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6512
6513   // An external install for an even higher priority install source should
6514   // succeed if the version is greater.
6515   EXPECT_TRUE(
6516       service()->OnExternalExtensionFileFound(kGoodId,
6517                                               &newer_version,
6518                                               kInvalidPathToCrx,
6519                                               Manifest::EXTERNAL_REGISTRY,
6520                                               kCreationFlags,
6521                                               kDontMarkAcknowledged));
6522   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6523
6524   // Because EXTERNAL_PREF is a lower priority source than EXTERNAL_REGISTRY,
6525   // adding from external pref will now fail.
6526   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6527                                                        &newer_version,
6528                                                        kInvalidPathToCrx,
6529                                                        Manifest::EXTERNAL_PREF,
6530                                                        kCreationFlags,
6531                                                        kDontMarkAcknowledged));
6532   EXPECT_TRUE(pending->IsIdPending(kGoodId));
6533 }
6534
6535 TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) {
6536   Version kVersion123("1.2.3");
6537   Version kVersion124("1.2.4");
6538   Version kVersion125("1.2.5");
6539   const base::FilePath kInvalidPathToCrx = base::FilePath();
6540   const int kCreationFlags = 0;
6541   const bool kDontMarkAcknowledged = false;
6542
6543   InitializeEmptyExtensionService();
6544
6545   extensions::PendingExtensionManager* pending =
6546       service()->pending_extension_manager();
6547   EXPECT_FALSE(pending->IsIdPending(kGoodId));
6548
6549   // An external provider starts installing from a local crx.
6550   EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
6551                                                       &kVersion123,
6552                                                       kInvalidPathToCrx,
6553                                                       Manifest::EXTERNAL_PREF,
6554                                                       kCreationFlags,
6555                                                       kDontMarkAcknowledged));
6556   const extensions::PendingExtensionInfo* info;
6557   EXPECT_TRUE((info = pending->GetById(kGoodId)));
6558   EXPECT_TRUE(info->version().IsValid());
6559   EXPECT_TRUE(info->version().Equals(kVersion123));
6560
6561   // Adding a newer version overrides the currently pending version.
6562   EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
6563                                                       &kVersion124,
6564                                                       kInvalidPathToCrx,
6565                                                       Manifest::EXTERNAL_PREF,
6566                                                       kCreationFlags,
6567                                                       kDontMarkAcknowledged));
6568   EXPECT_TRUE((info = pending->GetById(kGoodId)));
6569   EXPECT_TRUE(info->version().IsValid());
6570   EXPECT_TRUE(info->version().Equals(kVersion124));
6571
6572   // Adding an older version fails.
6573   EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
6574                                                        &kVersion123,
6575                                                        kInvalidPathToCrx,
6576                                                        Manifest::EXTERNAL_PREF,
6577                                                        kCreationFlags,
6578                                                        kDontMarkAcknowledged));
6579   EXPECT_TRUE((info = pending->GetById(kGoodId)));
6580   EXPECT_TRUE(info->version().IsValid());
6581   EXPECT_TRUE(info->version().Equals(kVersion124));
6582
6583   // Adding an older version fails even when coming from a higher-priority
6584   // location.
6585   EXPECT_FALSE(
6586       service()->OnExternalExtensionFileFound(kGoodId,
6587                                               &kVersion123,
6588                                               kInvalidPathToCrx,
6589                                               Manifest::EXTERNAL_REGISTRY,
6590                                               kCreationFlags,
6591                                               kDontMarkAcknowledged));
6592   EXPECT_TRUE((info = pending->GetById(kGoodId)));
6593   EXPECT_TRUE(info->version().IsValid());
6594   EXPECT_TRUE(info->version().Equals(kVersion124));
6595
6596   // Adding the latest version from the webstore overrides a specific version.
6597   GURL kUpdateUrl("http://example.com/update");
6598   EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
6599       kGoodId,
6600       std::string(),
6601       kUpdateUrl,
6602       Manifest::EXTERNAL_POLICY_DOWNLOAD,
6603       Extension::NO_FLAGS,
6604       false));
6605   EXPECT_TRUE((info = pending->GetById(kGoodId)));
6606   EXPECT_FALSE(info->version().IsValid());
6607 }
6608
6609 // This makes sure we can package and install CRX files that use whitelisted
6610 // permissions.
6611 TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
6612   std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
6613   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
6614       extensions::switches::kWhitelistedExtensionID, test_id);
6615
6616   InitializeEmptyExtensionService();
6617   base::FilePath path = data_dir().AppendASCII("permissions");
6618   base::FilePath pem_path = path
6619       .AppendASCII("whitelist.pem");
6620   path = path
6621       .AppendASCII("whitelist");
6622
6623   const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
6624   EXPECT_EQ(0u, GetErrors().size());
6625   ASSERT_EQ(1u, registry()->enabled_extensions().size());
6626   EXPECT_EQ(test_id, extension->id());
6627 }
6628
6629 // Test that when multiple sources try to install an extension,
6630 // we consistently choose the right one. To make tests easy to read,
6631 // methods that fake requests to install crx files in several ways
6632 // are provided.
6633 class ExtensionSourcePriorityTest : public ExtensionServiceTest {
6634  public:
6635   virtual void SetUp() {
6636     ExtensionServiceTest::SetUp();
6637
6638     // All tests use a single extension.  Put the id and path in member vars
6639     // that all methods can read.
6640     crx_id_ = kGoodId;
6641     crx_path_ = data_dir().AppendASCII("good.crx");
6642   }
6643
6644   // Fake an external source adding a URL to fetch an extension from.
6645   bool AddPendingExternalPrefUrl() {
6646     return service()->pending_extension_manager()->AddFromExternalUpdateUrl(
6647         crx_id_,
6648         std::string(),
6649         GURL(),
6650         Manifest::EXTERNAL_PREF_DOWNLOAD,
6651         Extension::NO_FLAGS,
6652         false);
6653   }
6654
6655   // Fake an external file from external_extensions.json.
6656   bool AddPendingExternalPrefFileInstall() {
6657     Version version("1.0.0.0");
6658
6659     return service()->OnExternalExtensionFileFound(crx_id_,
6660                                                    &version,
6661                                                    crx_path_,
6662                                                    Manifest::EXTERNAL_PREF,
6663                                                    Extension::NO_FLAGS,
6664                                                    false);
6665   }
6666
6667   // Fake a request from sync to install an extension.
6668   bool AddPendingSyncInstall() {
6669     return service()->pending_extension_manager()->AddFromSync(
6670         crx_id_,
6671         GURL(kGoodUpdateURL),
6672         &IsExtension,
6673         kGoodInstallSilently,
6674         kGoodRemoteInstall,
6675         kGoodInstalledByCustodian);
6676   }
6677
6678   // Fake a policy install.
6679   bool AddPendingPolicyInstall() {
6680     // Get path to the CRX with id |kGoodId|.
6681     return service()->OnExternalExtensionUpdateUrlFound(
6682         crx_id_,
6683         std::string(),
6684         GURL(),
6685         Manifest::EXTERNAL_POLICY_DOWNLOAD,
6686         Extension::NO_FLAGS,
6687         false);
6688   }
6689
6690   // Get the install source of a pending extension.
6691   Manifest::Location GetPendingLocation() {
6692     const extensions::PendingExtensionInfo* info;
6693     EXPECT_TRUE(
6694         (info = service()->pending_extension_manager()->GetById(crx_id_)));
6695     return info->install_source();
6696   }
6697
6698   // Is an extension pending from a sync request?
6699   bool GetPendingIsFromSync() {
6700     const extensions::PendingExtensionInfo* info;
6701     EXPECT_TRUE(
6702         (info = service()->pending_extension_manager()->GetById(crx_id_)));
6703     return info->is_from_sync();
6704   }
6705
6706   // Is the CRX id these tests use pending?
6707   bool IsCrxPending() {
6708     return service()->pending_extension_manager()->IsIdPending(crx_id_);
6709   }
6710
6711   // Is an extension installed?
6712   bool IsCrxInstalled() {
6713     return (service()->GetExtensionById(crx_id_, true) != NULL);
6714   }
6715
6716  protected:
6717   // All tests use a single extension.  Making the id and path member
6718   // vars avoids pasing the same argument to every method.
6719   std::string crx_id_;
6720   base::FilePath crx_path_;
6721 };
6722
6723 // Test that a pending request for installation of an external CRX from
6724 // an update URL overrides a pending request to install the same extension
6725 // from sync.
6726 TEST_F(ExtensionSourcePriorityTest, PendingExternalFileOverSync) {
6727   InitializeEmptyExtensionService();
6728
6729   ASSERT_FALSE(IsCrxInstalled());
6730
6731   // Install pending extension from sync.
6732   content::WindowedNotificationObserver observer(
6733       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6734       content::NotificationService::AllSources());
6735   EXPECT_TRUE(AddPendingSyncInstall());
6736   ASSERT_EQ(Manifest::INTERNAL, GetPendingLocation());
6737   EXPECT_TRUE(GetPendingIsFromSync());
6738   ASSERT_FALSE(IsCrxInstalled());
6739
6740   // Install pending as external prefs json would.
6741   AddPendingExternalPrefFileInstall();
6742   ASSERT_EQ(Manifest::EXTERNAL_PREF, GetPendingLocation());
6743   ASSERT_FALSE(IsCrxInstalled());
6744
6745   // Another request from sync should be ignored.
6746   EXPECT_FALSE(AddPendingSyncInstall());
6747   ASSERT_EQ(Manifest::EXTERNAL_PREF, GetPendingLocation());
6748   ASSERT_FALSE(IsCrxInstalled());
6749
6750   observer.Wait();
6751   VerifyCrxInstall(crx_path_, INSTALL_NEW);
6752   ASSERT_TRUE(IsCrxInstalled());
6753 }
6754
6755 // Test that an install of an external CRX from an update overrides
6756 // an install of the same extension from sync.
6757 TEST_F(ExtensionSourcePriorityTest, PendingExternalUrlOverSync) {
6758   InitializeEmptyExtensionService();
6759   ASSERT_FALSE(IsCrxInstalled());
6760
6761   EXPECT_TRUE(AddPendingSyncInstall());
6762   ASSERT_EQ(Manifest::INTERNAL, GetPendingLocation());
6763   EXPECT_TRUE(GetPendingIsFromSync());
6764   ASSERT_FALSE(IsCrxInstalled());
6765
6766   ASSERT_TRUE(AddPendingExternalPrefUrl());
6767   ASSERT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, GetPendingLocation());
6768   EXPECT_FALSE(GetPendingIsFromSync());
6769   ASSERT_FALSE(IsCrxInstalled());
6770
6771   EXPECT_FALSE(AddPendingSyncInstall());
6772   ASSERT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, GetPendingLocation());
6773   EXPECT_FALSE(GetPendingIsFromSync());
6774   ASSERT_FALSE(IsCrxInstalled());
6775 }
6776
6777 // Test that an external install request stops sync from installing
6778 // the same extension.
6779 TEST_F(ExtensionSourcePriorityTest, InstallExternalBlocksSyncRequest) {
6780   InitializeEmptyExtensionService();
6781   ASSERT_FALSE(IsCrxInstalled());
6782
6783   // External prefs starts an install.
6784   AddPendingExternalPrefFileInstall();
6785
6786   // Crx installer was made, but has not yet run.
6787   ASSERT_FALSE(IsCrxInstalled());
6788
6789   // Before the CRX installer runs, Sync requests that the same extension
6790   // be installed. Should fail, because an external source is pending.
6791   content::WindowedNotificationObserver observer(
6792       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6793       content::NotificationService::AllSources());
6794   ASSERT_FALSE(AddPendingSyncInstall());
6795
6796   // Wait for the external source to install.
6797   observer.Wait();
6798   VerifyCrxInstall(crx_path_, INSTALL_NEW);
6799   ASSERT_TRUE(IsCrxInstalled());
6800
6801   // Now that the extension is installed, sync request should fail
6802   // because the extension is already installed.
6803   ASSERT_FALSE(AddPendingSyncInstall());
6804 }
6805
6806 // Test that installing an external extension displays a GlobalError.
6807 TEST_F(ExtensionServiceTest, ExternalInstallGlobalError) {
6808   FeatureSwitch::ScopedOverride prompt(
6809       FeatureSwitch::prompt_for_external_extensions(), true);
6810
6811   InitializeEmptyExtensionService();
6812   MockExtensionProvider* provider =
6813       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
6814   AddMockExternalProvider(provider);
6815
6816   service()->external_install_manager()->UpdateExternalExtensionAlert();
6817   // Should return false, meaning there aren't any extensions that the user
6818   // needs to know about.
6819   EXPECT_FALSE(
6820       service()->external_install_manager()->HasExternalInstallError());
6821
6822   // This is a normal extension, installed normally.
6823   // This should NOT trigger an alert.
6824   service()->set_extensions_enabled(true);
6825   base::FilePath path = data_dir().AppendASCII("good.crx");
6826   InstallCRX(path, INSTALL_NEW);
6827
6828   service()->CheckForExternalUpdates();
6829   base::RunLoop().RunUntilIdle();
6830   EXPECT_FALSE(
6831       service()->external_install_manager()->HasExternalInstallError());
6832
6833   // A hosted app, installed externally.
6834   // This should NOT trigger an alert.
6835   provider->UpdateOrAddExtension(
6836       hosted_app, "1.0.0.0", data_dir().AppendASCII("hosted_app.crx"));
6837
6838   content::WindowedNotificationObserver observer(
6839       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6840       content::NotificationService::AllSources());
6841   service()->CheckForExternalUpdates();
6842   observer.Wait();
6843   EXPECT_FALSE(
6844       service()->external_install_manager()->HasExternalInstallError());
6845
6846   // Another normal extension, but installed externally.
6847   // This SHOULD trigger an alert.
6848   provider->UpdateOrAddExtension(
6849       page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
6850
6851   content::WindowedNotificationObserver observer2(
6852       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6853       content::NotificationService::AllSources());
6854   service()->CheckForExternalUpdates();
6855   observer2.Wait();
6856   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
6857 }
6858
6859 // Test that external extensions are initially disabled, and that enabling
6860 // them clears the prompt.
6861 TEST_F(ExtensionServiceTest, ExternalInstallInitiallyDisabled) {
6862   FeatureSwitch::ScopedOverride prompt(
6863       FeatureSwitch::prompt_for_external_extensions(), true);
6864
6865   InitializeEmptyExtensionService();
6866   MockExtensionProvider* provider =
6867       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
6868   AddMockExternalProvider(provider);
6869
6870   provider->UpdateOrAddExtension(
6871       page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
6872
6873   content::WindowedNotificationObserver observer(
6874       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6875       content::NotificationService::AllSources());
6876   service()->CheckForExternalUpdates();
6877   observer.Wait();
6878   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
6879   EXPECT_FALSE(service()->IsExtensionEnabled(page_action));
6880
6881   const Extension* extension =
6882       registry()->disabled_extensions().GetByID(page_action);
6883   EXPECT_TRUE(extension);
6884   EXPECT_EQ(page_action, extension->id());
6885
6886   service()->EnableExtension(page_action);
6887   EXPECT_FALSE(
6888       service()->external_install_manager()->HasExternalInstallError());
6889   EXPECT_TRUE(service()->IsExtensionEnabled(page_action));
6890 }
6891
6892 // Test that installing multiple external extensions works.
6893 // Flaky on windows; http://crbug.com/295757 .
6894 #if defined(OS_WIN)
6895 #define MAYBE_ExternalInstallMultiple DISABLED_ExternalInstallMultiple
6896 #else
6897 #define MAYBE_ExternalInstallMultiple ExternalInstallMultiple
6898 #endif
6899 TEST_F(ExtensionServiceTest, MAYBE_ExternalInstallMultiple) {
6900   FeatureSwitch::ScopedOverride prompt(
6901       FeatureSwitch::prompt_for_external_extensions(), true);
6902
6903   InitializeEmptyExtensionService();
6904   MockExtensionProvider* provider =
6905       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
6906   AddMockExternalProvider(provider);
6907
6908   provider->UpdateOrAddExtension(
6909       page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
6910   provider->UpdateOrAddExtension(
6911       good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
6912   provider->UpdateOrAddExtension(
6913       theme_crx, "2.0", data_dir().AppendASCII("theme.crx"));
6914
6915   int count = 3;
6916   content::WindowedNotificationObserver observer(
6917       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6918       base::Bind(&WaitForCountNotificationsCallback, &count));
6919   service()->CheckForExternalUpdates();
6920   observer.Wait();
6921   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
6922   EXPECT_FALSE(service()->IsExtensionEnabled(page_action));
6923   EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
6924   EXPECT_FALSE(service()->IsExtensionEnabled(theme_crx));
6925
6926   service()->EnableExtension(page_action);
6927   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
6928   EXPECT_FALSE(service()
6929                    ->external_install_manager()
6930                    ->HasExternalInstallBubbleForTesting());
6931
6932   service()->EnableExtension(theme_crx);
6933   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
6934   EXPECT_FALSE(service()
6935                    ->external_install_manager()
6936                    ->HasExternalInstallBubbleForTesting());
6937
6938   service()->EnableExtension(good_crx);
6939   EXPECT_FALSE(
6940       service()->external_install_manager()->HasExternalInstallError());
6941   EXPECT_FALSE(service()
6942                    ->external_install_manager()
6943                    ->HasExternalInstallBubbleForTesting());
6944 }
6945
6946 // Test that there is a bubble for external extensions that update
6947 // from the webstore if the profile is not new.
6948 TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreOldProfile) {
6949   FeatureSwitch::ScopedOverride prompt(
6950       FeatureSwitch::prompt_for_external_extensions(), true);
6951
6952   // This sets up the ExtensionPrefs used by our ExtensionService to be
6953   // post-first run.
6954   ExtensionServiceInitParams params = CreateDefaultInitParams();
6955   params.is_first_run = false;
6956   InitializeExtensionService(params);
6957
6958   base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
6959   PackCRX(data_dir().AppendASCII("update_from_webstore"),
6960           data_dir().AppendASCII("update_from_webstore.pem"),
6961           crx_path);
6962
6963   MockExtensionProvider* provider =
6964       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
6965   AddMockExternalProvider(provider);
6966   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
6967
6968   content::WindowedNotificationObserver observer(
6969       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6970       content::NotificationService::AllSources());
6971   service()->CheckForExternalUpdates();
6972   observer.Wait();
6973   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
6974   EXPECT_TRUE(service()
6975                   ->external_install_manager()
6976                   ->HasExternalInstallBubbleForTesting());
6977   EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
6978 }
6979
6980 // Test that there is no bubble for external extensions if the profile is new.
6981 TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreNewProfile) {
6982   FeatureSwitch::ScopedOverride prompt(
6983       FeatureSwitch::prompt_for_external_extensions(), true);
6984
6985   InitializeEmptyExtensionService();
6986
6987   base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
6988   PackCRX(data_dir().AppendASCII("update_from_webstore"),
6989           data_dir().AppendASCII("update_from_webstore.pem"),
6990           crx_path);
6991
6992   MockExtensionProvider* provider =
6993       new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
6994   AddMockExternalProvider(provider);
6995   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
6996
6997   content::WindowedNotificationObserver observer(
6998       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
6999       content::NotificationService::AllSources());
7000   service()->CheckForExternalUpdates();
7001   observer.Wait();
7002   EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
7003   EXPECT_FALSE(service()
7004                    ->external_install_manager()
7005                    ->HasExternalInstallBubbleForTesting());
7006   EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
7007 }
7008
7009 // Test that clicking to remove the extension on an external install warning
7010 // uninstalls the extension.
7011 TEST_F(ExtensionServiceTest, ExternalInstallClickToRemove) {
7012   FeatureSwitch::ScopedOverride prompt(
7013       FeatureSwitch::prompt_for_external_extensions(), true);
7014
7015   ExtensionServiceInitParams params = CreateDefaultInitParams();
7016   params.is_first_run = false;
7017   InitializeExtensionService(params);
7018
7019   base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
7020   PackCRX(data_dir().AppendASCII("update_from_webstore"),
7021           data_dir().AppendASCII("update_from_webstore.pem"),
7022           crx_path);
7023
7024   MockExtensionProvider* provider =
7025       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
7026   AddMockExternalProvider(provider);
7027   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
7028
7029   content::WindowedNotificationObserver observer(
7030       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
7031       content::NotificationService::AllSources());
7032   service_->CheckForExternalUpdates();
7033   observer.Wait();
7034   EXPECT_TRUE(service_->external_install_manager()->HasExternalInstallError());
7035
7036   // We check both enabled and disabled, since these are "eventually exclusive"
7037   // sets.
7038   EXPECT_TRUE(registry()->disabled_extensions().GetByID(updates_from_webstore));
7039   EXPECT_FALSE(registry()->enabled_extensions().GetByID(updates_from_webstore));
7040
7041   // Click the negative response.
7042   service_->external_install_manager()->error_for_testing()->InstallUIAbort(
7043       true);
7044   // The Extension should be uninstalled.
7045   EXPECT_FALSE(registry()->GetExtensionById(updates_from_webstore,
7046                                             ExtensionRegistry::EVERYTHING));
7047   // The error should be removed.
7048   EXPECT_FALSE(service_->external_install_manager()->HasExternalInstallError());
7049 }
7050
7051 // Test that clicking to keep the extension on an external install warning
7052 // re-enables the extension.
7053 TEST_F(ExtensionServiceTest, ExternalInstallClickToKeep) {
7054   FeatureSwitch::ScopedOverride prompt(
7055       FeatureSwitch::prompt_for_external_extensions(), true);
7056
7057   ExtensionServiceInitParams params = CreateDefaultInitParams();
7058   params.is_first_run = false;
7059   InitializeExtensionService(params);
7060
7061   base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
7062   PackCRX(data_dir().AppendASCII("update_from_webstore"),
7063           data_dir().AppendASCII("update_from_webstore.pem"),
7064           crx_path);
7065
7066   MockExtensionProvider* provider =
7067       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
7068   AddMockExternalProvider(provider);
7069   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
7070
7071   content::WindowedNotificationObserver observer(
7072       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
7073       content::NotificationService::AllSources());
7074   service_->CheckForExternalUpdates();
7075   observer.Wait();
7076   EXPECT_TRUE(service_->external_install_manager()->HasExternalInstallError());
7077
7078   // We check both enabled and disabled, since these are "eventually exclusive"
7079   // sets.
7080   EXPECT_TRUE(registry()->disabled_extensions().GetByID(updates_from_webstore));
7081   EXPECT_FALSE(registry()->enabled_extensions().GetByID(updates_from_webstore));
7082
7083   // Accept the extension.
7084   service_->external_install_manager()->error_for_testing()->InstallUIProceed();
7085
7086   // It should be enabled again.
7087   EXPECT_TRUE(registry()->enabled_extensions().GetByID(updates_from_webstore));
7088   EXPECT_FALSE(
7089       registry()->disabled_extensions().GetByID(updates_from_webstore));
7090
7091   // The error should be removed.
7092   EXPECT_FALSE(service_->external_install_manager()->HasExternalInstallError());
7093 }
7094
7095 TEST_F(ExtensionServiceTest, InstallBlacklistedExtension) {
7096   InitializeEmptyExtensionService();
7097
7098   scoped_refptr<Extension> extension = extensions::ExtensionBuilder()
7099       .SetManifest(extensions::DictionaryBuilder()
7100           .Set("name", "extension")
7101           .Set("version", "1.0")
7102           .Set("manifest_version", 2).Build())
7103       .Build();
7104   ASSERT_TRUE(extension.get());
7105   const std::string& id = extension->id();
7106
7107   std::set<std::string> id_set;
7108   id_set.insert(id);
7109   extensions::ExtensionNotificationObserver notifications(
7110       content::NotificationService::AllSources(), id_set);
7111
7112   // Installation should be allowed but the extension should never have been
7113   // loaded and it should be blacklisted in prefs.
7114   service()->OnExtensionInstalled(
7115       extension.get(),
7116       syncer::StringOrdinal(),
7117       (extensions::kInstallFlagIsBlacklistedForMalware |
7118        extensions::kInstallFlagInstallImmediately));
7119   base::RunLoop().RunUntilIdle();
7120
7121   // Extension was installed but not loaded.
7122   EXPECT_TRUE(notifications.CheckNotifications(
7123       extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED));
7124   EXPECT_TRUE(service()->GetInstalledExtension(id));
7125
7126   EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
7127   EXPECT_TRUE(registry()->blacklisted_extensions().Contains(id));
7128
7129   EXPECT_TRUE(ExtensionPrefs::Get(profile())->IsExtensionBlacklisted(id));
7130   EXPECT_TRUE(
7131       ExtensionPrefs::Get(profile())->IsBlacklistedExtensionAcknowledged(id));
7132 }
7133
7134 // Tests a profile being destroyed correctly disables extensions.
7135 TEST_F(ExtensionServiceTest, DestroyingProfileClearsExtensions) {
7136   InitializeEmptyExtensionService();
7137
7138   InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
7139   EXPECT_NE(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
7140   EXPECT_EQ(1u, registry()->enabled_extensions().size());
7141   EXPECT_EQ(0u, registry()->disabled_extensions().size());
7142   EXPECT_EQ(0u, registry()->terminated_extensions().size());
7143   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
7144
7145   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
7146                      content::Source<Profile>(profile()),
7147                      content::NotificationService::NoDetails());
7148   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
7149   EXPECT_EQ(0u, registry()->enabled_extensions().size());
7150   EXPECT_EQ(0u, registry()->disabled_extensions().size());
7151   EXPECT_EQ(0u, registry()->terminated_extensions().size());
7152   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
7153 }