Pull CrxInstaller out of ExtensionsService.

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2009 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 "base/file_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/net/test_url_fetcher_factory.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 76 matching lines @@
  public:
   MockService() {}
   virtual ~MockService() {}
 
   virtual const ExtensionList* extensions() const {
     EXPECT_TRUE(false);
     return NULL;
   }
 
   virtual void UpdateExtension(const std::string& id,
-                               const FilePath& extension_path,
-                               bool alert_on_error,
-                               ExtensionInstallCallback* callback) {
+                               const FilePath& extension_path) {
     EXPECT_TRUE(false);
   }
 
   virtual Extension* GetExtensionById(const std::string& id) {
     EXPECT_TRUE(false);
     return NULL;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockService);
@@ skipping 43 matching lines @@
   void set_extensions(ExtensionList extensions) {
     extensions_ = extensions;
   }
 
  private:
   ExtensionList extensions_;
 };
 
 class ServiceForDownloadTests : public MockService {
  public:
-  explicit ServiceForDownloadTests() : callback_(NULL) {}
-  virtual ~ServiceForDownloadTests() {
-    // expect that cleanup happened via FireInstallCallback
-    EXPECT_EQ(NULL, callback_);
-    EXPECT_TRUE(install_path_.empty());
-  }
-
   virtual void UpdateExtension(const std::string& id,
-                               const FilePath& extension_path,
-                               bool alert_on_error,
-                               ExtensionInstallCallback* callback) {
-    // Since this mock only has support for one oustanding update, ensure
-    // that the callback doesn't need to be run.
-    EXPECT_TRUE(install_path_.empty());
-    EXPECT_EQ(NULL, callback_);
-
+                               const FilePath& extension_path) {
     extension_id_ = id;
     install_path_ = extension_path;
-    callback_ = callback;
-  }
-
-  void FireInstallCallback() {
-    EXPECT_TRUE(callback_ != NULL);
-    callback_->Run(install_path_, static_cast<Extension*>(NULL));
-    delete callback_;
-    callback_ = NULL;
-    install_path_ = FilePath();
   }
 
   const std::string& extension_id() { return extension_id_; }
   const FilePath& install_path() { return install_path_; }
 
  private:
   std::string extension_id_;
   FilePath install_path_;
-  ExtensionInstallCallback* callback_;
 };
 
 static const int kUpdateFrequencySecs = 15;
 
 // Takes a string with KEY=VALUE parameters separated by '&' in |params| and
 // puts the key/value pairs into |result|. For keys with no value, the empty
 // string is used. So for "a=1&b=foo&c", result would map "a" to "1", "b" to
 // "foo", and "c" to "".
 static void ExtractParameters(const std::string params,
                               std::map<std::string, std::string>* result) {
@@ skipping 200 matching lines @@
 
     // 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());
     FilePath tmpfile_path = service.install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     std::string file_contents;
     EXPECT_TRUE(file_util::ReadFileToString(tmpfile_path, &file_contents));
     EXPECT_TRUE(extension_data == file_contents);
 
-    service.FireInstallCallback();
-
-    message_loop.RunAllPending();
-
-    // Make sure the temp file is cleaned up
-    EXPECT_FALSE(file_util::PathExists(tmpfile_path));
-
     URLFetcher::set_factory(NULL);
   }
 
   static void TestMultipleExtensionDownloading() {
     MessageLoopForUI message_loop;
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     ServiceForDownloadTests service;
     scoped_refptr<ExtensionUpdater> updater =
@@ skipping 11 matching lines @@
 
     // Make the first fetch complete.
     std::string extension_data1("whatever");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url1, URLRequestStatus(), 200, ResponseCookies(),
         extension_data1);
     message_loop.RunAllPending();
 
-    // Expect that the service was asked to do an install with the right data,
-    // and fire the callback indicating the install finished.
+    // Expect that the service was asked to do an install with the right data.
     FilePath tmpfile_path = service.install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(id1, service.extension_id());
-    service.FireInstallCallback();
-
-    // Make sure the tempfile got cleaned up.
     message_loop.RunAllPending();
-    EXPECT_FALSE(tmpfile_path.empty());
-    EXPECT_FALSE(file_util::PathExists(tmpfile_path));
 
     // Make sure the second fetch finished and asked the service to do an
     // update.
     std::string extension_data2("whatever2");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url2, URLRequestStatus(), 200, ResponseCookies(),
         extension_data2);
     message_loop.RunAllPending();
     EXPECT_EQ(id2, service.extension_id());
     EXPECT_FALSE(service.install_path().empty());
 
     // Make sure the correct crx contents were passed for the update call.
     std::string file_contents;
     EXPECT_TRUE(file_util::ReadFileToString(service.install_path(),
                                             &file_contents));
     EXPECT_TRUE(extension_data2 == file_contents);
-    service.FireInstallCallback();
-    message_loop.RunAllPending();
   }
 };
 
 // Because we test some private methods of ExtensionUpdater, it's easer for the
 // actual test code to live in ExtenionUpdaterTest methods instead of TEST_F
 // subclasses where friendship with ExtenionUpdater is not inherited.
 
 TEST(ExtensionUpdaterTest, TestXmlParsing) {
   ExtensionUpdaterTest::TestXmlParsing();
 }
@@ skipping 23 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -Profile::GetDefaultRequestContext() returning null
 //  (should not crash, but just do check later)
 // -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