Create CrxInstaller directly in WebstoreInstaller

chrome/browser/extensions/updater/extension_updater_unittest.cc

 // Copyright (c) 2012 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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 393 matching lines @@
   // Add a fake crx installer to be returned by a call to UpdateExtension()
   // with a specific ID.  Caller keeps ownership of |crx_installer|.
   void AddFakeCrxInstaller(const std::string& id, CrxInstaller* crx_installer) {
     fake_crx_installers_[id] = crx_installer;
   }
 
   virtual bool UpdateExtension(
       const std::string& id,
       const base::FilePath& extension_path,
       bool file_ownership_passed,
-      const GURL& download_url,
       CrxInstaller** out_crx_installer) OVERRIDE {
     extension_id_ = id;
     install_path_ = extension_path;
-    download_url_ = download_url;
 
     if (ContainsKey(fake_crx_installers_, id)) {
       *out_crx_installer = fake_crx_installers_[id];
       return true;
     }
 
     return false;
   }
 
   virtual PendingExtensionManager* pending_extension_manager() OVERRIDE {
     return &pending_extension_manager_;
   }
 
   virtual const Extension* GetExtensionById(
       const std::string& id, bool) const OVERRIDE {
     last_inquired_extension_id_ = id;
     return NULL;
   }
 
   const std::string& extension_id() const { return extension_id_; }
   const base::FilePath& install_path() const { return install_path_; }
-  const GURL& download_url() const { return download_url_; }
 
  private:
   // Hold the set of ids that UpdateExtension() should fake success on.
   // UpdateExtension(id, ...) will return true iff fake_crx_installers_
   // contains key |id|.  |out_install_notification_source| will be set
   // to Source<CrxInstaller(fake_crx_installers_[i]).
   std::map<std::string, CrxInstaller*> fake_crx_installers_;
 
   std::string extension_id_;
   base::FilePath install_path_;
@@ skipping 620 matching lines @@
 
     if (fail) {
       // Don't expect any extension to have been installed.
       EXPECT_TRUE(service->extension_id().empty());
     } else {
       // Expect that ExtensionUpdater asked the mock extensions service to
       // install a file with the test data for the right id.
       EXPECT_EQ(id, service->extension_id());
       base::FilePath tmpfile_path = service->install_path();
       EXPECT_FALSE(tmpfile_path.empty());
-      EXPECT_EQ(test_url, service->download_url());
       EXPECT_EQ(extension_file_path, tmpfile_path);
     }
   }
 
   // Update a single extension in an environment where the download request
   // initially responds with a 403 status. Expect the fetcher to automatically
   // retry with cookies enabled.
   void TestSingleProtectedExtensionDownloading(bool use_https, bool fail) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
@@ skipping 62 matching lines @@
       fetcher->set_status(net::URLRequestStatus());
       fetcher->set_response_code(200);
       fetcher->SetResponseFilePath(extension_file_path);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
       RunUntilIdle();
 
       // Verify installation would proceed as normal.
       EXPECT_EQ(id, service->extension_id());
       base::FilePath tmpfile_path = service->install_path();
       EXPECT_FALSE(tmpfile_path.empty());
-      EXPECT_EQ(test_url, service->download_url());
       EXPECT_EQ(extension_file_path, tmpfile_path);
     }
   }
 
   // Two extensions are updated.  If |updates_start_running| is true, the
   // mock extensions service has UpdateExtension(...) return true, and
   // the test is responsible for creating fake CrxInstallers.  Otherwise,
   // UpdateExtension() returns false, signaling install failures.
   void TestMultipleExtensionDownloading(bool updates_start_running) {
     net::TestURLFetcherFactory factory;
@@ skipping 77 matching lines @@
     fetcher->set_response_code(200);
     fetcher->SetResponseFilePath(extension_file_path);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     RunUntilIdle();
 
     // Expect that the service was asked to do an install with the right data.
     base::FilePath tmpfile_path = service.install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(id1, service.extension_id());
-    EXPECT_EQ(url1, service.download_url());
     RunUntilIdle();
 
     // Make sure the second fetch finished and asked the service to do an
     // update.
     base::FilePath extension_file_path2(FILE_PATH_LITERAL("/whatever2"));
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
 
     fetcher->set_url(url2);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseFilePath(extension_file_path2);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunUntilIdle();
 
     if (updates_start_running) {
       EXPECT_TRUE(updater.crx_install_is_running_);
 
       // The second install should not have run, because the first has not
       // sent a notification that it finished.
       EXPECT_EQ(id1, service.extension_id());
-      EXPECT_EQ(url1, service.download_url());
 
       // Fake install notice.  This should start the second installation,
       // which will be checked below.
       fake_crx1->NotifyCrxInstallComplete(false);
 
       EXPECT_TRUE(updater.crx_install_is_running_);
     }
 
     EXPECT_EQ(id2, service.extension_id());
-    EXPECT_EQ(url2, service.download_url());
     EXPECT_FALSE(service.install_path().empty());
 
     // Make sure the correct crx contents were passed for the update call.
     EXPECT_EQ(extension_file_path2, service.install_path());
 
     if (updates_start_running) {
       EXPECT_TRUE(updater.crx_install_is_running_);
       fake_crx2->NotifyCrxInstallComplete(false);
     }
     EXPECT_FALSE(updater.crx_install_is_running_);
@@ skipping 484 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions