Observe adding external extensions via windows registry.

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 "chrome/browser/extensions/extension_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <map>
@@ skipping 79 matching lines @@
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_dialog_auto_confirm.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/external_extension_install_info.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/browser/test_management_policy.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_l10n_util.h"
@@ skipping 45 matching lines @@
 using extensions::APIPermissionSet;
 using extensions::AppSorting;
 using extensions::Blacklist;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionCreator;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionResource;
 using extensions::ExtensionSystem;
+using extensions::ExternalExtensionInstallInfoFile;
+using extensions::ExternalExtensionInstallInfoUpdateUrl;
 using extensions::ExternalInstallError;
+using extensions::ExternalProviderInterface;
 using extensions::FakeSafeBrowsingDatabaseManager;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
 using extensions::PermissionSet;
 using extensions::TestExtensionSystem;
 using extensions::UnloadedExtensionInfo;
 using extensions::URLPatternSet;
 
 namespace keys = extensions::manifest_keys;
 
@@ skipping 65 matching lines @@
 
   void RemoveExtension(const std::string& id) {
     extension_map_.erase(id);
   }
 
   // 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);
+      scoped_ptr<Version> version(new Version(i->second.first));
 
-      visitor_->OnExternalExtensionFileFound(
-          i->first, &version, i->second.second, location_,
-          Extension::NO_FLAGS, false, false);
+      scoped_ptr<ExternalExtensionInstallInfoFile> info(
+          new ExternalExtensionInstallInfoFile(
+              i->first, std::move(version), i->second.second, location_,
+              Extension::NO_FLAGS, false, false));
+      visitor_->OnExternalExtensionFileFound(info.get());
     }
     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 80 matching lines @@
     }
 
     // Reset our counter.
     ids_found_ = 0;
     // Ask the provider to look up all extensions and return them.
     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,
-                                    bool install_immediately) override {
-    EXPECT_EQ(expected_creation_flags_, creation_flags);
+  bool OnExternalExtensionFileFound(
+      ExternalExtensionInstallInfoFile* info) override {
+    EXPECT_EQ(expected_creation_flags_, info->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";
+    EXPECT_TRUE(prefs_->GetDictionary(info->extension_id, &pref))
+        << "Got back ID (" << info->extension_id.c_str()
+        << ") we weren't expecting";
 
-    EXPECT_TRUE(path.IsAbsolute());
+    EXPECT_TRUE(info->path.IsAbsolute());
     if (!fake_base_path_.empty())
-      EXPECT_TRUE(fake_base_path_.IsParent(path));
+      EXPECT_TRUE(fake_base_path_.IsParent(info->path));
 
     if (pref) {
-      EXPECT_TRUE(provider_->HasExtension(id));
+      EXPECT_TRUE(provider_->HasExtension(info->extension_id));
 
       // Ask provider if the extension we got back is registered.
       Manifest::Location location = Manifest::INVALID_LOCATION;
       scoped_ptr<Version> v1;
       base::FilePath crx_path;
 
-      EXPECT_TRUE(provider_->GetExtensionDetails(id, NULL, &v1));
-      EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
+      EXPECT_TRUE(
+          provider_->GetExtensionDetails(info->extension_id, NULL, &v1));
+      EXPECT_STREQ(info->version->GetString().c_str(), v1->GetString().c_str());
 
       scoped_ptr<Version> v2;
-      EXPECT_TRUE(provider_->GetExtensionDetails(id, &location, &v2));
-      EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
-      EXPECT_STREQ(version->GetString().c_str(), v2->GetString().c_str());
+      EXPECT_TRUE(
+          provider_->GetExtensionDetails(info->extension_id, &location, &v2));
+      EXPECT_STREQ(info->version->GetString().c_str(), v1->GetString().c_str());
+      EXPECT_STREQ(info->version->GetString().c_str(), v2->GetString().c_str());
       EXPECT_EQ(Manifest::EXTERNAL_PREF, location);
 
       // Remove it so we won't count it ever again.
-      prefs_->Remove(id, NULL);
+      prefs_->Remove(info->extension_id, NULL);
     }
     return true;
   }
 
-  bool OnExternalExtensionUpdateUrlFound(const std::string& id,
-                                         const std::string& install_parameter,
-                                         const GURL& update_url,
-                                         Manifest::Location location,
-                                         int creation_flags,
-                                         bool mark_acknowledged) override {
+  bool OnExternalExtensionUpdateUrlFound(
+      ExternalExtensionInstallInfoUpdateUrl* info,
+      bool is_initial_load) override {
     ++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))
-       << L"Got back ID (" << id.c_str() << ") we weren't expecting";
-    EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
+    EXPECT_TRUE(prefs_->GetDictionary(info->extension_id, &pref))
+        << L"Got back ID (" << info->extension_id.c_str()
+        << ") we weren't expecting";
+    EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, info->download_location);
 
     if (pref) {
-      EXPECT_TRUE(provider_->HasExtension(id));
+      EXPECT_TRUE(provider_->HasExtension(info->extension_id));
 
       // External extensions with update URLs do not have versions.
       scoped_ptr<Version> v1;
       Manifest::Location location1 = Manifest::INVALID_LOCATION;
-      EXPECT_TRUE(provider_->GetExtensionDetails(id, &location1, &v1));
+      EXPECT_TRUE(
+          provider_->GetExtensionDetails(info->extension_id, &location1, &v1));
       EXPECT_FALSE(v1.get());
       EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
 
       std::string parsed_install_parameter;
       pref->GetString("install_parameter", &parsed_install_parameter);
-      EXPECT_EQ(parsed_install_parameter, install_parameter);
+      EXPECT_EQ(parsed_install_parameter, info->install_parameter);
 
       // Remove it so we won't count it again.
-      prefs_->Remove(id, NULL);
+      prefs_->Remove(info->extension_id, NULL);
     }
     return true;
   }
 
+  void OnExternalProviderUpdateComplete(
+      const ExternalProviderInterface* provider,
+      const ScopedVector<ExternalExtensionInstallInfoUpdateUrl>&
+          update_url_extensions,
+      const ScopedVector<ExternalExtensionInstallInfoFile>& file_extensions,
+      const std::set<std::string>& removed_extensions) override {
+    ADD_FAILURE() << "Not tested path yet.";

[asargent_no_longer_on_chrome, 2016/01/25 18:50:52]

You should add a test for this =)
 

[lazyboy, 2016/01/26 05:20:04]

Done.
I've added a different provider since this one would quite give me what I'm
looking for.
Let me know if you have ideas to improve the test.
Thanks.

[asargent_no_longer_on_chrome, 2016/01/26 17:48:07]

I think what you've added is fine

+  }
+
   void OnExternalProviderReady(
       const extensions::ExternalProviderInterface* provider) override {
     EXPECT_EQ(provider, provider_.get());
     EXPECT_TRUE(provider->IsReady());
   }
 
   Profile* profile() { return profile_.get(); }
 
  private:
   int ids_found_;
@@ skipping 577 matching lines @@
 // extension object.
 TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
   const char kPrefFromBookmark[] = "from_bookmark";
 
   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");
+  scoped_ptr<Version> version(new 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 */,
-          false /* install_immediately */)) {
+  scoped_ptr<ExternalExtensionInstallInfoFile> info(
+      new ExternalExtensionInstallInfoFile(
+          good_crx, std::move(version), path, Manifest::EXTERNAL_PREF,
+          Extension::FROM_BOOKMARK, false /* mark_acknowledged */,
+          false /* install_immediately */));
+  if (service()->OnExternalExtensionFileFound(info.get()))
     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");
   UpdateExtension(good_crx, path, ENABLED);
   ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
   extension = service()->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
 }
 
 // Test the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
 TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // 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)) {
+  scoped_ptr<Version> version(new Version("1.0.0.0"));
+  scoped_ptr<ExternalExtensionInstallInfoFile> info(
+      new ExternalExtensionInstallInfoFile(good_crx, std::move(version), path,
+                                           Manifest::EXTERNAL_PREF,
+                                           Extension::NO_FLAGS, false, false));
+  if (service()->OnExternalExtensionFileFound(info.get()))
     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);
+  service()->OnExternalExtensionFileFound(info.get());
   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");
+  version.reset(new Version("1.0.0.0"));
   // 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);
+  info.reset(new ExternalExtensionInstallInfoFile(
+      good_crx, std::move(version), path, Manifest::EXTERNAL_PREF,
+      Extension::NO_FLAGS, false, false));
+  service()->OnExternalExtensionFileFound(info.get());
   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(),
       GURL("http:://fake.update/url"),
@@ skipping 30 matching lines @@
   MockExtensionProvider provider(NULL, Manifest::EXTERNAL_REGISTRY);
   service()->OnExternalProviderReady(&provider);
 }
 
 // Test that external extensions with incorrect IDs are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongId) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
-  Version version("1.0.0.0");
+  scoped_ptr<Version> version(new Version("1.0.0.0"));
 
   const std::string wrong_id = all_zero;
   const std::string correct_id = good_crx;
   ASSERT_NE(correct_id, wrong_id);
 
   // 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);
+  scoped_ptr<ExternalExtensionInstallInfoFile> info(
+      new ExternalExtensionInstallInfoFile(wrong_id, std::move(version), path,
+                                           Manifest::EXTERNAL_PREF,
+                                           Extension::NO_FLAGS, false, false));
+  service()->OnExternalExtensionFileFound(info.get());
 
   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)) {
+  info->extension_id = correct_id;
+  if (service()->OnExternalExtensionFileFound(info.get()))
     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);
+  scoped_ptr<Version> wrong_version(new Version("1.2.3.4"));
+  scoped_ptr<ExternalExtensionInstallInfoFile> info(
+      new ExternalExtensionInstallInfoFile(good_crx, std::move(wrong_version),
+                                           path, Manifest::EXTERNAL_PREF,
+                                           Extension::NO_FLAGS, false, false));
+  service()->OnExternalExtensionFileFound(info.get());
 
   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");
+  scoped_ptr<Version> correct_version(new Version("1.0.0.0"));
+  info->version = std::move(correct_version);
   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)) {
+  if (service()->OnExternalExtensionFileFound(info.get()))
     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.
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("user_script_basic.user.js");
@@ skipping 4039 matching lines @@
   InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Skip install when the location is the same.
-  EXPECT_FALSE(
-      service()->OnExternalExtensionUpdateUrlFound(kGoodId,
-                                                   std::string(),
-                                                   GURL(kGoodUpdateURL),
-                                                   Manifest::INTERNAL,
-                                                   Extension::NO_FLAGS,
-                                                   false));
+  scoped_ptr<GURL> good_update_url(new GURL(kGoodUpdateURL));
+  scoped_ptr<ExternalExtensionInstallInfoUpdateUrl> info(
+      new ExternalExtensionInstallInfoUpdateUrl(
+          kGoodId, std::string(), std::move(good_update_url),
+          Manifest::INTERNAL, Extension::NO_FLAGS, false));
+  EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(info.get(), true));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Install when the location has higher priority.
-  EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
-      kGoodId,
-      std::string(),
-      GURL(kGoodUpdateURL),
-      Manifest::EXTERNAL_POLICY_DOWNLOAD,
-      Extension::NO_FLAGS,
-      false));
+  info->download_location = Manifest::EXTERNAL_POLICY_DOWNLOAD;
+  EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(info.get(), true));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // Try the low priority again.  Should be rejected.
-  EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(
-      kGoodId,
-      std::string(),
-      GURL(kGoodUpdateURL),
-      Manifest::EXTERNAL_PREF_DOWNLOAD,
-      Extension::NO_FLAGS,
-      false));
+  info->download_location = Manifest::EXTERNAL_PREF_DOWNLOAD;
+  EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(info.get(), true));
   // The existing record should still be present in the pending extension
   // manager.
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   pending->Remove(kGoodId);
 
   // Skip install when the location has the same priority as the installed
   // location.
-  EXPECT_FALSE(
-      service()->OnExternalExtensionUpdateUrlFound(kGoodId,
-                                                   std::string(),
-                                                   GURL(kGoodUpdateURL),
-                                                   Manifest::INTERNAL,
-                                                   Extension::NO_FLAGS,
-                                                   false));
+  info->download_location = Manifest::INTERNAL;
+  EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(info.get(), true));
 
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 }
 
 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.
@@ skipping 17 matching lines @@
             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));
 
+  scoped_ptr<Version> older_version_ptr(new Version(older_version));
+  scoped_ptr<ExternalExtensionInstallInfoFile> info(
+      new ExternalExtensionInstallInfoFile(
+          kGoodId, std::move(older_version_ptr), kInvalidPathToCrx,
+          Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged,
+          kDontInstallImmediately));
   {
     // 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,
-        kDontInstallImmediately));
+    EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
     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,
-        kDontInstallImmediately));
+    info->crx_location = Manifest::EXTERNAL_PREF;
+    EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
     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,
-      kDontInstallImmediately));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // Try INTERNAL again.  Should fail.
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
-      kGoodId,
-      &older_version,
-      kInvalidPathToCrx,
-      Manifest::INTERNAL,
-      kCreationFlags,
-      kDontMarkAcknowledged,
-      kDontInstallImmediately));
+  info->crx_location = Manifest::INTERNAL;
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   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,
-        kDontInstallImmediately));
+    info->crx_location = Manifest::EXTERNAL_REGISTRY;
+    EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
     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,
-      kDontInstallImmediately));
+  info->crx_location = Manifest::EXTERNAL_PREF;
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
-      kGoodId,
-      &older_version,
-      kInvalidPathToCrx,
-      Manifest::INTERNAL,
-      kCreationFlags,
-      kDontMarkAcknowledged,
-      kDontInstallImmediately));
+  info->crx_location = Manifest::INTERNAL;
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   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,
-      kDontInstallImmediately));
+  info->version.reset(new Version(older_version));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Same version as the installed version...
-  EXPECT_FALSE(service()->OnExternalExtensionFileFound(
-      kGoodId,
-      ext->version(),
-      kInvalidPathToCrx,
-      Manifest::INTERNAL,
-      kCreationFlags,
-      kDontMarkAcknowledged,
-      kDontInstallImmediately));
+  info->version.reset(new Version(ext->VersionString()));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Newer than the installed version...
-  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
-      kGoodId,
-      &newer_version,
-      kInvalidPathToCrx,
-      Manifest::INTERNAL,
-      kCreationFlags,
-      kDontMarkAcknowledged,
-      kDontInstallImmediately));
+  info->version.reset(new Version(newer_version));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
   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,
-      kDontInstallImmediately));
+  info->version.reset(new Version(older_version));
+  info->crx_location = Manifest::EXTERNAL_PREF;
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // |newer_version| is newer.
-  EXPECT_TRUE(service()->OnExternalExtensionFileFound(
-      kGoodId,
-      &newer_version,
-      kInvalidPathToCrx,
-      Manifest::EXTERNAL_PREF,
-      kCreationFlags,
-      kDontMarkAcknowledged,
-      kDontInstallImmediately));
+  info->version.reset(new Version(newer_version));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
   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,
-      kDontInstallImmediately));
+  info->crx_location = Manifest::EXTERNAL_REGISTRY;
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
   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,
-      kDontInstallImmediately));
+  info->crx_location = Manifest::EXTERNAL_PREF;
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
   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,
-      kDontInstallImmediately));
-  const extensions::PendingExtensionInfo* info;
-  EXPECT_TRUE((info = pending->GetById(kGoodId)));
-  EXPECT_TRUE(info->version().IsValid());
-  EXPECT_TRUE(info->version().Equals(kVersion123));
+  scoped_ptr<ExternalExtensionInstallInfoFile> info(
+      new ExternalExtensionInstallInfoFile(
+          kGoodId, make_scoped_ptr(new Version(kVersion123)), kInvalidPathToCrx,
+          Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged,
+          kDontInstallImmediately));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
+  const extensions::PendingExtensionInfo* pending_info;
+  EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(pending_info->version().IsValid());
+  EXPECT_TRUE(pending_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,
-      kDontInstallImmediately));
-  EXPECT_TRUE((info = pending->GetById(kGoodId)));
-  EXPECT_TRUE(info->version().IsValid());
-  EXPECT_TRUE(info->version().Equals(kVersion124));
+  info->version.reset(new Version(kVersion124));
+  EXPECT_TRUE(service()->OnExternalExtensionFileFound(info.get()));
+  EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(pending_info->version().IsValid());
+  EXPECT_TRUE(pending_info->version().Equals(kVersion124));
 
   // Adding an older version fails.
-  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));
+  info->version.reset(new Version(kVersion123));
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
+  EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(pending_info->version().IsValid());
+  EXPECT_TRUE(pending_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,
-      kDontInstallImmediately));
-  EXPECT_TRUE((info = pending->GetById(kGoodId)));
-  EXPECT_TRUE(info->version().IsValid());
-  EXPECT_TRUE(info->version().Equals(kVersion124));
+  info->crx_location = Manifest::EXTERNAL_REGISTRY;
+  EXPECT_FALSE(service()->OnExternalExtensionFileFound(info.get()));
+  EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(pending_info->version().IsValid());
+  EXPECT_TRUE(pending_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,
-      Manifest::EXTERNAL_POLICY_DOWNLOAD,
-      Extension::NO_FLAGS,
-      false));
-  EXPECT_TRUE((info = pending->GetById(kGoodId)));
-  EXPECT_FALSE(info->version().IsValid());
+  scoped_ptr<ExternalExtensionInstallInfoUpdateUrl> update_info(
+      new ExternalExtensionInstallInfoUpdateUrl(
+          kGoodId, std::string(), make_scoped_ptr(new GURL(kUpdateUrl)),
+          Manifest::EXTERNAL_POLICY_DOWNLOAD, Extension::NO_FLAGS, false));
+  EXPECT_TRUE(
+      service()->OnExternalExtensionUpdateUrlFound(update_info.get(), true));
+  EXPECT_TRUE((pending_info = pending->GetById(kGoodId)));
+  EXPECT_FALSE(pending_info->version().IsValid());
 }
 
 // This makes sure we can package and install CRX files that use whitelisted
 // permissions.
 TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
   std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       extensions::switches::kWhitelistedExtensionID, test_id);
 
   InitializeEmptyExtensionService();
@@ skipping 30 matching lines @@
         crx_id_,
         std::string(),
         GURL(),
         Manifest::EXTERNAL_PREF_DOWNLOAD,
         Extension::NO_FLAGS,
         false);
   }
 
   // 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);
+    scoped_ptr<Version> version(new Version("1.0.0.0"));
+    scoped_ptr<ExternalExtensionInstallInfoFile> info(
+        new ExternalExtensionInstallInfoFile(
+            crx_id_, std::move(version), crx_path_, Manifest::EXTERNAL_PREF,
+            Extension::NO_FLAGS, false, false));
+    return service()->OnExternalExtensionFileFound(info.get());
   }
 
   // Fake a request from sync to install an extension.
   bool AddPendingSyncInstall() {
     return service()->pending_extension_manager()->AddFromSync(
         crx_id_,
         GURL(kGoodUpdateURL),
         base::Version(),
         &IsExtension,
         kGoodRemoteInstall,
         kGoodInstalledByCustodian);
   }
 
   // Fake a policy install.
   bool AddPendingPolicyInstall() {
     // Get path to the CRX with id |kGoodId|.
-    return service()->OnExternalExtensionUpdateUrlFound(
-        crx_id_,
-        std::string(),
-        GURL(),
-        Manifest::EXTERNAL_POLICY_DOWNLOAD,
-        Extension::NO_FLAGS,
-        false);
+    scoped_ptr<GURL> empty_url(new GURL());
+    scoped_ptr<ExternalExtensionInstallInfoUpdateUrl> info(
+        new ExternalExtensionInstallInfoUpdateUrl(
+            crx_id_, std::string(), std::move(empty_url),
+            Manifest::EXTERNAL_POLICY_DOWNLOAD, Extension::NO_FLAGS, false));
+    return service()->OnExternalExtensionUpdateUrlFound(info.get(), true);
   }
 
   // Get the install source of a pending extension.
   Manifest::Location GetPendingLocation() {
     const extensions::PendingExtensionInfo* info;
     EXPECT_TRUE(
         (info = service()->pending_extension_manager()->GetById(crx_id_)));
     return info->install_source();
   }
 
@@ skipping 513 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());
 }