Pull CrxInstaller out of ExtensionsService.

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 81 matching lines @@
   virtual void VisitRegisteredExtension(
       Visitor* visitor, const std::set<std::string>& ids_to_ignore) const {
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
       if (ids_to_ignore.find(i->first) != ids_to_ignore.end())
         continue;
       scoped_ptr<Version> version;
       version.reset(Version::GetVersionFromString(i->second.first));
 
       visitor->OnExternalExtensionFound(
-          i->first, version.get(), i->second.second);
+          i->first, version.get(), i->second.second, location_);
     }
   }
 
   virtual Version* RegisteredVersion(const std::string& id,
                                      Extension::Location* location) const {
     DataMap::const_iterator it = extension_map_.find(id);
     if (it == extension_map_.end())
       return NULL;
 
     if (location)
@@ skipping 40 matching lines @@
     ids_found_ = 0;
     // Ask the provider to look up all extensions (and return the ones
     // found (that are not on the ignore list).
     provider_->VisitRegisteredExtension(this, ignore_list);
 
     return ids_found_;
   }
 
   virtual void OnExternalExtensionFound(const std::string& id,
                                         const Version* version,
-                                        const FilePath& path) {
+                                        const FilePath& path,
+                                        Extension::Location unused) {
     ++ids_found_;
     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(ASCIIToWide(id), &pref))
        << L"Got back ID (" << id.c_str() << ") we weren't expecting";
 
     if (pref) {
       // Ask provider if the extension we got back is registered.
@@ skipping 36 matching lines @@
       const FilePath& extensions_install_dir) {
     prefs_.reset(new PrefService(pref_file, NULL));
     profile_.reset(new TestingProfile());
     service_ = new ExtensionsService(profile_.get(),
                                      CommandLine::ForCurrentProcess(),
                                      prefs_.get(),
                                      extensions_install_dir,
                                      &loop_,
                                      &loop_,
                                      false);
-    service_->SetExtensionsEnabled(true);
+    service_->set_extensions_enabled(true);
     service_->set_show_extensions_prompts(false);
 
     // When we start up, we want to make sure there is no external provider,
     // since the ExtensionService on Windows will use the Registry as a default
     // provider and if there is something already registered there then it will
     // interfere with the tests. Those tests that need an external provider
     // will register one specifically.
     service_->ClearProvidersForTesting();
 
     total_successes_ = 0;
@@ skipping 70 matching lines @@
       case NotificationType::EXTENSION_INSTALLED:
       case NotificationType::THEME_INSTALLED:
         installed_ = Details<Extension>(details).ptr();
         break;
 
       default:
         DCHECK(false);
     }
   }
 
-  void SetExtensionsEnabled(bool enabled) {
-    service_->SetExtensionsEnabled(enabled);
+  void set_extensions_enabled(bool enabled) {
+    service_->set_extensions_enabled(enabled);
   }
 
   void SetMockExternalProvider(Extension::Location location,
                                ExternalExtensionProvider* provider) {
     service_->SetProviderForTesting(location, provider);
   }
 
  protected:
-  // A class to record whether a ExtensionInstallCallback has fired, and
-  // to remember the args it was called with.
-  class CallbackRecorder {
-   public:
-    CallbackRecorder() : was_called_(false), path_(NULL), extension_(NULL) {}
-
-    void CallbackFunc(const FilePath& path, Extension* extension) {
-      was_called_ = true;
-      path_.reset(new FilePath(path));
-      extension_ = extension;
-    }
-
-    bool was_called() { return was_called_; }
-    const FilePath* path() { return path_.get(); }
-    Extension* extension() { return extension_; }
-
-   private:
-    bool was_called_;
-    scoped_ptr<FilePath> path_;
-    Extension* extension_;
-  };
-
   void InstallExtension(const FilePath& path,
                         bool should_succeed) {
     ASSERT_TRUE(file_util::PathExists(path));
     service_->InstallExtension(path);
     loop_.RunAllPending();
     std::vector<std::string> errors = GetErrors();
     if (should_succeed) {
       ++total_successes_;
 
       EXPECT_TRUE(installed_) << path.value();
@@ skipping 13 matching lines @@
       EXPECT_EQ(0u, loaded_.size()) << path.value();
       EXPECT_EQ(1u, errors.size()) << path.value();
     }
 
     installed_ = NULL;
     loaded_.clear();
     ExtensionErrorReporter::GetInstance()->ClearErrors();
   }
 
   void UpdateExtension(const std::string& id, const FilePath& path,
-                       bool should_succeed, bool use_callback,
-                       bool expect_report_on_failure) {
+                       bool should_succeed, bool expect_report_on_failure) {
     ASSERT_TRUE(file_util::PathExists(path));
 
-    CallbackRecorder callback_recorder;
-    ExtensionInstallCallback* callback = NULL;
-    if (use_callback) {
-      callback = NewCallback(&callback_recorder,
-                             &CallbackRecorder::CallbackFunc);
-    }
-
-    service_->UpdateExtension(id, path, false, callback);
+    service_->UpdateExtension(id, path);
     loop_.RunAllPending();
     std::vector<std::string> errors = GetErrors();
 
-    if (use_callback) {
-      EXPECT_TRUE(callback_recorder.was_called());
-      EXPECT_TRUE(path == *callback_recorder.path());
-    }
-
     if (should_succeed) {
       EXPECT_EQ(0u, errors.size()) << path.value();
       EXPECT_EQ(1u, service_->extensions()->size());
-      if (use_callback) {
-        EXPECT_EQ(service_->extensions()->at(0), callback_recorder.extension());
-      }
     } else {
       if (expect_report_on_failure) {
         EXPECT_EQ(1u, errors.size()) << path.value();
       }
-      if (use_callback) {
-        EXPECT_EQ(NULL, callback_recorder.extension());
-      }
     }
+
+    // Update() should delete the temporary input file.
+    EXPECT_FALSE(file_util::PathExists(path));
   }
 
   void ValidatePrefKeyCount(size_t count) {
     DictionaryValue* dict =
         prefs_->GetMutableDictionary(L"extensions.settings");
     ASSERT_TRUE(dict != NULL);
     EXPECT_EQ(count, dict->GetSize());
   }
 
   void ValidatePref(const std::string& extension_id,
@@ skipping 249 matching lines @@
 // crx files. If you need to change those crx files, feel free to repackage
 // them, throw away the key used and change the id's above.
 TEST_F(ExtensionsServiceTest, InstallExtension) {
   InitializeEmptyExtensionsService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // Extensions not enabled.
-  SetExtensionsEnabled(false);
+  set_extensions_enabled(false);
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, false);
-  SetExtensionsEnabled(true);
+  set_extensions_enabled(true);
 
   ValidatePrefKeyCount(0);
 
   // A simple extension that should install without error.
   path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
   // TODO(erikkay): verify the contents of the installed extension.
 
   int pref_count = 0;
   ValidatePrefKeyCount(++pref_count);
@@ skipping 101 matching lines @@
   // A theme.
   FilePath path = extensions_path.AppendASCII("theme.crx");
   InstallExtension(path, true);
   int pref_count = 0;
   ValidatePrefKeyCount(++pref_count);
   ValidatePref(theme_crx, L"state", Extension::ENABLED);
   ValidatePref(theme_crx, L"location", Extension::INTERNAL);
 
   // A theme when extensions are disabled. Themes can be installed, even when
   // extensions are disabled.
-  SetExtensionsEnabled(false);
+  set_extensions_enabled(false);
   path = extensions_path.AppendASCII("theme2.crx");
   InstallExtension(path, true);
   ValidatePrefKeyCount(++pref_count);
   ValidatePref(theme2_crx, L"state", Extension::ENABLED);
   ValidatePref(theme2_crx, L"location", Extension::INTERNAL);
 
   // A theme with extension elements. Themes cannot have extension elements so
   // this test should fail.
-  SetExtensionsEnabled(true);
+  set_extensions_enabled(true);
   path = extensions_path.AppendASCII("theme_with_extension.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
   // A theme with image resources missing (misspelt path).
   path = extensions_path.AppendASCII("theme_missing_image.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 }
 
@@ skipping 94 matching lines @@
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   path = extensions_path.AppendASCII("good2.crx");
-  UpdateExtension(good_crx, path, true, true, true);
+  UpdateExtension(good_crx, path, true, true);
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
 }
 
-// Test doing an update without passing a completion callback
-TEST_F(ExtensionsServiceTest, UpdateWithoutCallback) {
-  InitializeEmptyExtensionsService();
-  FilePath extensions_path;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
-  extensions_path = extensions_path.AppendASCII("extensions");
-
-  FilePath path = extensions_path.AppendASCII("good.crx");
-
-  InstallExtension(path, true);
-  Extension* good = service_->extensions()->at(0);
-  ASSERT_EQ("1.0.0.0", good->VersionString());
-  ASSERT_EQ(good_crx, good->id());
-
-  path = extensions_path.AppendASCII("good2.crx");
-  UpdateExtension(good_crx, path, true, false, true);
-  ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
-}
-
 // Test updating a not-already-installed extension - this should fail
 TEST_F(ExtensionsServiceTest, UpdateNotInstalledExtension) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
-  service_->UpdateExtension(good_crx, path, false, NULL);
+  service_->UpdateExtension(good_crx, path);
   loop_.RunAllPending();
 
   ASSERT_EQ(0u, service_->extensions()->size());
   ASSERT_FALSE(installed_);
   ASSERT_EQ(0u, loaded_.size());
 }
 
 // Makes sure you can't downgrade an extension via UpdateExtension
 TEST_F(ExtensionsServiceTest, UpdateWillNotDowngrade) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good2.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.1", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   // Change path from good2.crx -> good.crx
   path = extensions_path.AppendASCII("good.crx");
-  UpdateExtension(good_crx, path, false, true, true);
+  UpdateExtension(good_crx, path, false, true);
   ASSERT_EQ("1.0.0.1", service_->extensions()->at(0)->VersionString());
 }
 
 // Make sure calling update with an identical version does nothing
 TEST_F(ExtensionsServiceTest, UpdateToSameVersionIsNoop) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ(good_crx, good->id());
-  UpdateExtension(good_crx, path, false, true, false);
+  UpdateExtension(good_crx, path, false, false);
 }
 
 // Tests uninstalling normal extensions
 TEST_F(ExtensionsServiceTest, UninstallExtension) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
@@ skipping 118 matching lines @@
   // --load-extension doesn't add entries to prefs
   ValidatePrefKeyCount(0);
 }
 
 // Tests the external installation feature
 #if defined(OS_WIN)
 
 TEST_F(ExtensionsServiceTest, ExternalInstallRegistry) {
   // This should all work, even when normal extension installation is disabled.
   InitializeEmptyExtensionsService();
-  SetExtensionsEnabled(false);
+  set_extensions_enabled(false);
   // Verify that starting with no providers loads no extensions.
   service_->Init();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
 
   // Now add providers. Extension system takes ownership of the objects.
   MockExtensionProvider* reg_provider =
       new MockExtensionProvider(Extension::EXTERNAL_REGISTRY);
   SetMockExternalProvider(Extension::EXTERNAL_REGISTRY, reg_provider);
 
@@ skipping 184 matching lines @@
   service_->LoadAllExtensions();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
   ValidatePrefKeyCount(0);
 
   // The extension should also be gone from the install directory.
   ASSERT_FALSE(file_util::PathExists(install_path));
 
   // It should still work if extensions are disabled (disableness doesn't
   // apply to externally registered extensions).
-  SetExtensionsEnabled(false);
+  set_extensions_enabled(false);
 
   pref_provider->UpdateOrAddExtension(good_crx, "1.0", source_path);
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
 
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(0u, GetErrors().size());
 }
 
 TEST_F(ExtensionsServiceTest, ExternalPrefProvider) {
@@ skipping 116 matching lines @@
 
   recorder.set_ready(false);
   command_line.reset(new CommandLine(L""));
   service = new ExtensionsService(&profile, command_line.get(),
       profile.GetPrefs(), install_dir, &loop, &loop, false);
   EXPECT_TRUE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 }