Cause new_chrome.exe to always be written if Chrome Frame is in use, resulting in updates being d...

chrome/installer/util/installer_state.cc

 // Copyright (c) 2011 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/installer/util/installer_state.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
+#include "base/win/scoped_handle.h"
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/work_item_list.h"
 
@@ skipping 40 matching lines @@
 }
 
 InstallerState::InstallerState()
     : operation_(UNINITIALIZED),
       multi_package_distribution_(NULL),
       level_(UNKNOWN_LEVEL),
       package_type_(UNKNOWN_PACKAGE_TYPE),
       state_type_(BrowserDistribution::CHROME_BROWSER),
       root_key_(NULL),
       msi_(false),
-      verbose_logging_(false) {
+      verbose_logging_(false),
+      is_chrome_frame_running_(false) {
 }
 
 InstallerState::InstallerState(Level level)
     : operation_(UNINITIALIZED),
       multi_package_distribution_(NULL),
       level_(UNKNOWN_LEVEL),
       package_type_(UNKNOWN_PACKAGE_TYPE),
       state_type_(BrowserDistribution::CHROME_BROWSER),
       root_key_(NULL),
       msi_(false),
-      verbose_logging_(false) {
+      verbose_logging_(false),
+      is_chrome_frame_running_(false) {
   // Use set_level() so that root_key_ is updated properly.
   set_level(level);
 }
 
 void InstallerState::Initialize(const CommandLine& command_line,
                                 const MasterPreferences& prefs,
                                 const InstallationState& machine_state) {
   bool pref_bool;
   if (!prefs.GetBool(master_preferences::kSystemLevel, &pref_bool))
     pref_bool = false;
@@ skipping 48 matching lines @@
 
   if (operand == NULL) {
     operand = BrowserDistribution::GetSpecificDistribution(
         prefs.install_chrome() ?
             BrowserDistribution::CHROME_BROWSER :
             BrowserDistribution::CHROME_FRAME);
   }
 
   state_key_ = operand->GetStateKey();
   state_type_ = operand->GetType();
+
+  is_chrome_frame_running_ = DetectChromeFrameInUse(machine_state);
 }
 
 void InstallerState::set_level(Level level) {
   level_ = level;
   switch (level) {
     case USER_LEVEL:
       root_key_ = HKEY_CURRENT_USER;
       break;
     case SYSTEM_LEVEL:
       root_key_ = HKEY_LOCAL_MACHINE;
@@ skipping 242 matching lines @@
   }
 
   return current_version.release();
 }
 
 FilePath InstallerState::GetInstallerDirectory(const Version& version) const {
   return target_path().Append(ASCIIToWide(version.GetString()))
       .Append(kInstallerDir);
 }
 
+// static
+bool InstallerState::IsFileInUse(const FilePath& file) {
+  // Call CreateFile with a share mode of 0 which should cause this to fail
+  // with ERROR_SHARING_VIOLATION if the file exists and is in-use.
+  return !base::win::ScopedHandle(CreateFile(file.value().c_str(),
+                                             GENERIC_WRITE, 0, NULL,
+                                             OPEN_EXISTING, 0, 0)).IsValid();
+}
+
+bool InstallerState::DetectChromeFrameInUse(
+    const InstallationState& machine_state) {
+  // We check only for the current version (e.g. the version we are upgrading
+  // _from_). We don't need to check interstitial versions if any (as would
+  // occur in the case of multiple updates) since if they are in use, we are
+  // guaranteed that the current version is in use too.
+  bool in_use = false;
+  scoped_ptr<Version> current_version(GetCurrentVersion(machine_state));
+  if (current_version != NULL) {
+    FilePath cf_install_path(
+        target_path().AppendASCII(current_version->GetString())
+                     .Append(kChromeFrameDll));
+    in_use = IsFileInUse(cf_install_path);
+  }
+  return in_use;
+}
+
 void InstallerState::RemoveOldVersionDirectories(
     const Version& new_version,
     Version* existing_version,
     const FilePath& temp_path) const {
   file_util::FileEnumerator version_enum(target_path(), false,
       file_util::FileEnumerator::DIRECTORIES);
   scoped_ptr<Version> version;
   std::vector<FilePath> key_files;
 
   // We try to delete all directories whose versions are lower than
@@ skipping 149 matching lines @@
   if (is_multi_install()) {
     InstallUtil::AddInstallerResultItems(
         system_install, multi_package_binaries_distribution()->GetStateKey(),
         status, string_resource_id, launch_cmd, install_list.get());
   }
   if (!install_list->Do())
     LOG(ERROR) << "Failed to record installer error information in registry.";
 }
 
 }  // namespace installer