Get rid of the extension's "Current Version" file.

chrome/browser/extensions/crx_installer.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 "chrome/browser/extensions/crx_installer.h"
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
@@ skipping 153 matching lines @@
   DCHECK(MessageLoop::current() == ui_loop_);
   if (frontend_->extension_prefs()->IsExtensionBlacklisted(extension_->id())) {
     LOG(INFO) << "This extension: " << extension_->id()
       << " is blacklisted. Install failed.";
     if (client_.get()) {
       client_->OnInstallFailure("This extension is blacklisted.");
     }
     return;
   }
 
+  current_version_ =
+      frontend_->extension_prefs()->GetVersionString(extension_->id());
+
   if (client_.get()) {
     AddRef();  // balanced in ContinueInstall() and AbortInstall().
     client_->ConfirmInstall(this, extension_.get(), install_icon_.get());
   } else {
     file_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &CrxInstaller::CompleteInstall));
   }
   return;
 }
 
 void CrxInstaller::ContinueInstall() {
   file_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &CrxInstaller::CompleteInstall));
 
   Release();  // balanced in ConfirmInstall().
 }
 
 void CrxInstaller::AbortInstall() {
   Release();  // balanced in ConfirmInstall().
 
   // We're done. Since we don't post any more tasks to ourself, our ref count
   // should go to zero and we die. The destructor will clean up the temp dir.
 }
 
 void CrxInstaller::CompleteInstall() {
   DCHECK(MessageLoop::current() == file_loop_);
 
   FilePath version_dir;
-  Extension::InstallType install_type = Extension::INSTALL_ERROR;
-  std::string error_msg;
-  if (!extension_file_util::InstallExtension(unpacked_extension_root_,
-                                             install_directory_,
-                                             extension_->id(),
-                                             extension_->VersionString(),
-                                             &version_dir,
-                                             &install_type, &error_msg)) {
-    ReportFailureFromFileThread(error_msg);
-    return;
-  }
+  Extension::InstallType install_type =
+      extension_file_util::CompareToInstalledVersion(
+          install_directory_, extension_->id(), current_version_,
+          extension_->VersionString(), &version_dir);
 
   if (install_type == Extension::DOWNGRADE) {
     ReportFailureFromFileThread("Attempted to downgrade extension.");
     return;
   }
 
   if (install_type == Extension::REINSTALL) {
     // We use this as a signal to switch themes.
     ReportOverinstallFromFileThread();
     return;
   }
 
+  std::string error_msg;
+  if (!extension_file_util::InstallExtension(unpacked_extension_root_,
+                                             version_dir, &error_msg)) {
+    ReportFailureFromFileThread(error_msg);
+    return;
+  }
+
   // This is lame, but we must reload the extension because absolute paths
   // inside the content scripts are established inside InitFromValue() and we
   // just moved the extension.
   // TODO(aa): All paths to resources inside extensions should be created
   // lazily and based on the Extension's root path at that moment.
   std::string error;
   extension_.reset(extension_file_util::LoadExtension(version_dir, true,
                                                       &error));
   DCHECK(error.empty());
   extension_->set_location(install_source_);
@@ skipping 49 matching lines @@
   if (client_.get())
     client_->OnInstallSuccess(extension_.get());
 
   // Tell the frontend about the installation and hand off ownership of
   // extension_ to it.
   frontend_->OnExtensionInstalled(extension_.release());
 
   // We're done. We don't post any more tasks to ourselves so we are deleted
   // soon.
 }