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"
 
+
 namespace installer {
 
 bool InstallerState::IsMultiInstallUpdate(const MasterPreferences& prefs,
     const InstallationState& machine_state) {
   // First, is the package present?
   const ProductState* package =
       machine_state.GetProductState(level_ == SYSTEM_LEVEL,
                                     BrowserDistribution::CHROME_BINARIES);
   if (package == NULL) {
     // The multi-install package has not been installed, so it certainly isn't
@@ skipping 30 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 165 matching lines @@
 bool InstallerState::system_install() const {
   DCHECK(level_ == USER_LEVEL || level_ == SYSTEM_LEVEL);
   return level_ == SYSTEM_LEVEL;
 }
 
 bool InstallerState::is_multi_install() const {
   DCHECK(package_type_ == SINGLE_PACKAGE || package_type_ == MULTI_PACKAGE);
   return package_type_ != SINGLE_PACKAGE;
 }
 
+bool InstallerState::is_chrome_frame_running() const {

[grt (UTC plus 2), 2011/07/14 14:25:29]

move this trivial method into the header.  (the two methods above aren't since
they do DCHECKs.)

[robertshield, 2011/07/15 13:49:18]

Done.

+  return is_chrome_frame_running_;
+}
+
 bool InstallerState::RemoveProduct(const Product* product) {
   ScopedVector<Product>::iterator it =
       std::find(products_.begin(), products_.end(), product);
   if (it != products_.end()) {
     products_->erase(it);
     return true;
   }
   return false;
 }
 
@@ skipping 56 matching lines @@
     current_version.reset(version->Clone());
   }
 
   return current_version.release();
 }
 
 FilePath InstallerState::GetInstallerDirectory(const Version& version) const {
   return target_path().Append(ASCIIToWide(version.GetString()))
       .Append(kInstallerDir);
 }
 

[grt (UTC plus 2), 2011/07/14 14:25:29]

add "// static" comment

[robertshield, 2011/07/15 13:49:18]

Done.

+bool InstallerState::IsFileInUse(const FilePath& file) {
+  bool in_use = true;
+  // 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.
+  base::win::ScopedHandle file_handle(CreateFile(file.value().c_str(),

[grt (UTC plus 2), 2011/07/14 14:25:29]

this function could be reduced to:

return !base::win::ScopedHandle(CreateFile(...)).IsValid();

[robertshield, 2011/07/15 13:49:18]

Done.

+                                                 GENERIC_WRITE, 0, NULL,
+                                                 OPEN_EXISTING, 0, 0));
+  if (file_handle.IsValid()) {
+    in_use = false;
+  }
+  return in_use;
+}
+

[grt (UTC plus 2), 2011/07/14 14:25:29]

consider adding a brief comment here explaining that it's only necessary to
check for the "current" version and not versions between that and the newest
version.

[robertshield, 2011/07/15 13:49:18]

Done.

+bool InstallerState::DetectChromeFrameInUse(
+    const InstallationState& machine_state) {
+  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