kiosk: Ensure launching latest version.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 252 matching lines @@
 
   // ExternalProvider implementation:
   void VisitRegisteredExtension() override {
     visit_count_++;
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
       Version version(i->second.first);
 
       visitor_->OnExternalExtensionFileFound(
           i->first, &version, i->second.second, location_,
-          Extension::NO_FLAGS, false);
+          Extension::NO_FLAGS, false, false);
     }
     visitor_->OnExternalProviderReady(this);
   }
 
   bool HasExtension(const std::string& id) const override {
     return extension_map_.find(id) != extension_map_.end();
   }
 
   bool GetExtensionDetails(const std::string& id,
                            Manifest::Location* location,
@@ skipping 86 matching lines @@
     provider_->VisitRegisteredExtension();
 
     return ids_found_;
   }
 
   bool OnExternalExtensionFileFound(const std::string& id,
                                     const Version* version,
                                     const base::FilePath& path,
                                     Manifest::Location unused,
                                     int creation_flags,
-                                    bool mark_acknowledged) override {
+                                    bool mark_acknowledged,
+                                    bool install_immediately) override {
     EXPECT_EQ(expected_creation_flags_, creation_flags);
 
     ++ids_found_;
     base::DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << "Got back ID (" << id.c_str() << ") we weren't expecting";
 
@@ skipping 1166 matching lines @@
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Register and install an external extension.
   Version version("1.0.0.0");
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  if (service()->OnExternalExtensionFileFound(good_crx,
-                                              &version,
-                                              path,
-                                              Manifest::EXTERNAL_PREF,
-                                              Extension::FROM_BOOKMARK,
-                                              false /* mark_acknowledged */)) {
+  if (service()->OnExternalExtensionFileFound(
+          good_crx,
+          &version,
+          path,
+          Manifest::EXTERNAL_PREF,
+          Extension::FROM_BOOKMARK,
+          false /* mark_acknowledged */,
+          false /* install_immediately */)) {
     observer.Wait();
   }
 
   const Extension* extension = service()->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
   ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
 
   // Upgrade to version 2.0, the flag should be preserved.
   path = data_dir().AppendASCII("good2.crx");
@@ skipping 14 matching lines @@
   // Install an external extension.
   Version version("1.0.0.0");
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(good_crx,
                                               &version,
                                               path,
                                               Manifest::EXTERNAL_PREF,
                                               Extension::NO_FLAGS,
+                                              false,
                                               false)) {
     observer.Wait();
   }
 
   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
 
   // Uninstall it and check that its killbit gets set.
   UninstallExtension(good_crx, false);
   ValidateIntegerPref(good_crx, "state",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   // Try to re-install it externally. This should fail because of the killbit.
   service()->OnExternalExtensionFileFound(good_crx,
                                           &version,
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
+                                          false,
                                           false);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "state",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   version = Version("1.0.0.1");
   // Repeat the same thing with a newer version of the extension.
   path = data_dir().AppendASCII("good2.crx");
   service()->OnExternalExtensionFileFound(good_crx,
                                           &version,
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
+                                          false,
                                           false);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "state",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   // Try adding the same extension from an external update URL.
   ASSERT_FALSE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
       good_crx,
       std::string(),
@@ skipping 47 matching lines @@
   // Install an external extension with an ID from the external
   // source that is not equal to the ID in the extension manifest.
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   service()->OnExternalExtensionFileFound(wrong_id,
                                           &version,
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
+                                          false,
                                           false);
 
   observer.Wait();
   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
 
   // Try again with the right ID. Expect success.
   content::WindowedNotificationObserver observer2(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(correct_id,
                                               &version,
                                               path,
                                               Manifest::EXTERNAL_PREF,
                                               Extension::NO_FLAGS,
+                                              false,
                                               false)) {
     observer2.Wait();
   }
   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
 }
 
 // Test that external extensions with incorrect versions are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Install an external extension with a version from the external
   // source that is not equal to the version in the extension manifest.
   Version wrong_version("1.2.3.4");
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   service()->OnExternalExtensionFileFound(good_crx,
                                           &wrong_version,
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
+                                          false,
                                           false);
 
   observer.Wait();
   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
 
   // Try again with the right version. Expect success.
   service()->pending_extension_manager()->Remove(good_crx);
   Version correct_version("1.0.0.0");
   content::WindowedNotificationObserver observer2(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(good_crx,
                                               &correct_version,
                                               path,
                                               Manifest::EXTERNAL_PREF,
                                               Extension::NO_FLAGS,
+                                              false,
                                               false)) {
     observer2.Wait();
   }
   ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
 }
 
 // Install a user script (they get converted automatically to an extension)
 TEST_F(ExtensionServiceTest, InstallUserScript) {
   // The details of script conversion are tested elsewhere, this just tests
   // integration with ExtensionService.
@@ skipping 5050 matching lines @@
 TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) {
   Version older_version("0.1.0.0");
   Version newer_version("2.0.0.0");
 
   // We don't want the extension to be installed.  A path that doesn't
   // point to a valid CRX ensures this.
   const base::FilePath kInvalidPathToCrx(FILE_PATH_LITERAL("invalid_path"));
 
   const int kCreationFlags = 0;
   const bool kDontMarkAcknowledged = false;
+  const bool kDontInstallImmediately = false;
 
   InitializeEmptyExtensionService();
 
   // The test below uses install source constants to test that
   // priority is enforced.  It assumes a specific ranking of install
   // sources: Registry (EXTERNAL_REGISTRY) overrides external pref
   // (EXTERNAL_PREF), and external pref overrides user install (INTERNAL).
   // The following assertions verify these assumptions:
   ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
                                                  Manifest::EXTERNAL_PREF));
   ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
                                                  Manifest::INTERNAL));
   ASSERT_EQ(Manifest::EXTERNAL_PREF,
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_PREF,
                                                  Manifest::INTERNAL));
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   {
     // Simulate an external source adding the extension as INTERNAL.
     content::WindowedNotificationObserver observer(
         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
         content::NotificationService::AllSources());
-    EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                        &older_version,
-                                                        kInvalidPathToCrx,
-                                                        Manifest::INTERNAL,
-                                                        kCreationFlags,
-                                                        kDontMarkAcknowledged));
+    EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+        kGoodId,
+        &older_version,
+        kInvalidPathToCrx,
+        Manifest::INTERNAL,
+        kCreationFlags,
+        kDontMarkAcknowledged,
+        kDontInstallImmediately));
     EXPECT_TRUE(pending->IsIdPending(kGoodId));
     observer.Wait();
     VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
   }
 
   {
     // Simulate an external source adding the extension as EXTERNAL_PREF.
     content::WindowedNotificationObserver observer(
         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
         content::NotificationService::AllSources());
-    EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                        &older_version,
-                                                        kInvalidPathToCrx,
-                                                        Manifest::EXTERNAL_PREF,
-                                                        kCreationFlags,
-                                                        kDontMarkAcknowledged));
+    EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+        kGoodId,
+        &older_version,
+        kInvalidPathToCrx,
+        Manifest::EXTERNAL_PREF,
+        kCreationFlags,
+        kDontMarkAcknowledged,
+        kDontInstallImmediately));
     EXPECT_TRUE(pending->IsIdPending(kGoodId));
     observer.Wait();
     VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
   }
 
   // Simulate an external source adding as EXTERNAL_PREF again.
   // This is rejected because the version and the location are the same as
   // the previous installation, which is still pending.
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &older_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::EXTERNAL_PREF,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &older_version,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // Try INTERNAL again.  Should fail.
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &older_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::INTERNAL,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &older_version,
+      kInvalidPathToCrx,
+      Manifest::INTERNAL,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   {
     // Now the registry adds the extension.
     content::WindowedNotificationObserver observer(
         extensions::NOTIFICATION_CRX_INSTALLER_DONE,
         content::NotificationService::AllSources());
-    EXPECT_TRUE(
-        service()->OnExternalExtensionFileFound(kGoodId,
-                                                &older_version,
-                                                kInvalidPathToCrx,
-                                                Manifest::EXTERNAL_REGISTRY,
-                                                kCreationFlags,
-                                                kDontMarkAcknowledged));
+    EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+        kGoodId,
+        &older_version,
+        kInvalidPathToCrx,
+        Manifest::EXTERNAL_REGISTRY,
+        kCreationFlags,
+        kDontMarkAcknowledged,
+        kDontInstallImmediately));
     EXPECT_TRUE(pending->IsIdPending(kGoodId));
     observer.Wait();
     VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
   }
 
   // Registry outranks both external pref and internal, so both fail.
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &older_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::EXTERNAL_PREF,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &older_version,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &older_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::INTERNAL,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &older_version,
+      kInvalidPathToCrx,
+      Manifest::INTERNAL,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   pending->Remove(kGoodId);
 
   // Install the extension.
   base::FilePath path = data_dir().AppendASCII("good.crx");
   const Extension* ext = InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 
   // Now test the logic of OnExternalExtensionFileFound() when the extension
   // being added is already installed.
 
   // Tests assume |older_version| is less than the installed version, and
   // |newer_version| is greater.  Verify this:
   ASSERT_TRUE(older_version.IsOlderThan(ext->VersionString()));
   ASSERT_TRUE(ext->version()->IsOlderThan(newer_version.GetString()));
 
   // An external install for the same location should fail if the version is
   // older, or the same, and succeed if the version is newer.
 
   // Older than the installed version...
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &older_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::INTERNAL,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &older_version,
+      kInvalidPathToCrx,
+      Manifest::INTERNAL,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Same version as the installed version...
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       ext->version(),
-                                                       kInvalidPathToCrx,
-                                                       Manifest::INTERNAL,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      ext->version(),
+      kInvalidPathToCrx,
+      Manifest::INTERNAL,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Newer than the installed version...
-  EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                      &newer_version,
-                                                      kInvalidPathToCrx,
-                                                      Manifest::INTERNAL,
-                                                      kCreationFlags,
-                                                      kDontMarkAcknowledged));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &newer_version,
+      kInvalidPathToCrx,
+      Manifest::INTERNAL,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // An external install for a higher priority install source should succeed
   // if the version is greater.  |older_version| is not...
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &older_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::EXTERNAL_PREF,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &older_version,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // |newer_version| is newer.
-  EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                      &newer_version,
-                                                      kInvalidPathToCrx,
-                                                      Manifest::EXTERNAL_PREF,
-                                                      kCreationFlags,
-                                                      kDontMarkAcknowledged));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &newer_version,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // An external install for an even higher priority install source should
   // succeed if the version is greater.
-  EXPECT_TRUE(
-      service()->OnExternalExtensionFileFound(kGoodId,
-                                              &newer_version,
-                                              kInvalidPathToCrx,
-                                              Manifest::EXTERNAL_REGISTRY,
-                                              kCreationFlags,
-                                              kDontMarkAcknowledged));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &newer_version,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_REGISTRY,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // Because EXTERNAL_PREF is a lower priority source than EXTERNAL_REGISTRY,
   // adding from external pref will now fail.
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &newer_version,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::EXTERNAL_PREF,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &newer_version,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 }
 
 TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) {
   Version kVersion123("1.2.3");
   Version kVersion124("1.2.4");
   Version kVersion125("1.2.5");
   const base::FilePath kInvalidPathToCrx(FILE_PATH_LITERAL("invalid_path"));
   const int kCreationFlags = 0;
   const bool kDontMarkAcknowledged = false;
+  const bool kDontInstallImmediately = false;
 
   InitializeEmptyExtensionService();
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // An external provider starts installing from a local crx.
-  EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                      &kVersion123,
-                                                      kInvalidPathToCrx,
-                                                      Manifest::EXTERNAL_PREF,
-                                                      kCreationFlags,
-                                                      kDontMarkAcknowledged));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &kVersion123,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   const extensions::PendingExtensionInfo* info;
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_TRUE(info->version().IsValid());
   EXPECT_TRUE(info->version().Equals(kVersion123));
 
   // Adding a newer version overrides the currently pending version.
-  EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                      &kVersion124,
-                                                      kInvalidPathToCrx,
-                                                      Manifest::EXTERNAL_PREF,
-                                                      kCreationFlags,
-                                                      kDontMarkAcknowledged));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &kVersion124,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_TRUE(info->version().IsValid());
   EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding an older version fails.
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
-                                                       &kVersion123,
-                                                       kInvalidPathToCrx,
-                                                       Manifest::EXTERNAL_PREF,
-                                                       kCreationFlags,
-                                                       kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &kVersion123,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_PREF,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_TRUE(info->version().IsValid());
   EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding an older version fails even when coming from a higher-priority
   // location.
-  EXPECT_FALSE(
-      service()->OnExternalExtensionFileFound(kGoodId,
-                                              &kVersion123,
-                                              kInvalidPathToCrx,
-                                              Manifest::EXTERNAL_REGISTRY,
-                                              kCreationFlags,
-                                              kDontMarkAcknowledged));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
+      kGoodId,
+      &kVersion123,
+      kInvalidPathToCrx,
+      Manifest::EXTERNAL_REGISTRY,
+      kCreationFlags,
+      kDontMarkAcknowledged,
+      kDontInstallImmediately));
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_TRUE(info->version().IsValid());
   EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding the latest version from the webstore overrides a specific version.
   GURL kUpdateUrl("http://example.com/update");
   EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
       kGoodId,
       std::string(),
       kUpdateUrl,
@@ skipping 52 matching lines @@
 
   // Fake an external file from external_extensions.json.
   bool AddPendingExternalPrefFileInstall() {
     Version version("1.0.0.0");
 
     return service()->OnExternalExtensionFileFound(crx_id_,
                                                    &version,
                                                    crx_path_,
                                                    Manifest::EXTERNAL_PREF,
                                                    Extension::NO_FLAGS,
+                                                   false,
                                                    false);
   }
 
   // Fake a request from sync to install an extension.
   bool AddPendingSyncInstall() {
     return service()->pending_extension_manager()->AddFromSync(
         crx_id_,
         GURL(kGoodUpdateURL),
         &IsExtension,
         kGoodRemoteInstall,
@@ skipping 469 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }