Add the Chrome version as one of the things we check to see if...

ceee/ie/common/ceee_module_util.cc

 // Copyright (c) 2010 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.
 //
 // CEEE module-wide utilities.
 
 #include "ceee/ie/common/ceee_module_util.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/win/registry.h"
 #include "ceee/common/process_utils_win.h"
 #include "chrome/installer/util/google_update_constants.h"
 
+#include "version.h"  // NOLINT
+
+// TODO(joi@chromium.org): would be nice to move these (and non-L counterparts)
+// to e.g. base/string_util.h
+#define LSTRINGIZE2(x) L ## #x
+#define LSTRINGIZE(x) LSTRINGIZE2(x)

[twiz, 2010/11/15 19:02:48]

Bummer.  Surprising that there wouldn't be common routines for this.

+
 namespace {
 
 const wchar_t* kRegistryPath = L"SOFTWARE\\Google\\CEEE";
 const wchar_t* kRegistryValueToolbandIsHidden = L"toolband_is_hidden";
 const wchar_t* kRegistryValueToolbandPlaced = L"toolband_placed";
 const wchar_t* kRegistryValueCrxInstalledPath = L"crx_installed_path";
 const wchar_t* kRegistryValueCrxInstalledTime = L"crx_installed_time";
+const wchar_t* kRegistryValueCrxInstalledByVersion =
+    L"crx_installed_runtime_version";
 
 // Global state needed by the BHO and the
 // toolband, to indicate whether ShowDW calls should affect
 // registry tracking of the user's visibility preference. A
 // non-zero value indicates that the calls should be ignored.
 LONG g_ignore_show_dw_changes = 0;
 
 bool GetCeeeRegistryBoolean(const wchar_t* key, bool default_value) {
   base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath, KEY_READ);
   LOG_IF(ERROR, !hkcu.Valid()) << "Could not open reg key: " << kRegistryPath;
@@ skipping 132 matching lines @@
   if (path.empty()) {
     // No extension to install, so no need to install the extension.
     return false;
   }
 
   const FilePath crx_path(path);
   if (IsCrxOrEmpty(crx_path.value())) {
     if (crx_path == GetInstalledExtensionPath()) {
       base::Time installed_time;
       base::PlatformFileInfo extension_info;
-      const bool success = file_util::GetFileInfo(crx_path, &extension_info);
+      bool success = file_util::GetFileInfo(crx_path, &extension_info);
       // If the call above didn't succeed, assume we need to install.
-      return !success ||
-          extension_info.last_modified > GetInstalledExtensionTime();
+      if (!success ||
+          extension_info.last_modified > GetInstalledExtensionTime()) {
+        return true;
+      } else {
+        // We also check that the current version of Chrome was the one
+        // that attempted installation; if not, changes such as a change
+        // in the location of a profile directory might have occurred, and
+        // we might need to retry installation.
+        std::wstring version_string;
+        base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath, KEY_READ);
+        success = hkcu.ReadValue(
+            kRegistryValueCrxInstalledByVersion, &version_string);
+        return !success || version_string != LSTRINGIZE(CHROME_VERSION_STRING);
+      }
     }
 
     return true;
   }
 
   return false;
 }
 
 void SetInstalledExtensionPath(const FilePath& path) {
   base::PlatformFileInfo extension_info;
   const bool success = file_util::GetFileInfo(path, &extension_info);
   const int64 crx_time = success ?
       extension_info.last_modified.ToInternalValue() :
       base::Time::Now().ToInternalValue();
 
   base::win::RegKey key(HKEY_CURRENT_USER, kRegistryPath, KEY_WRITE);
   bool write_result = key.WriteValue(kRegistryValueCrxInstalledTime,
                                      &crx_time,
                                      sizeof(crx_time),
                                      REG_QWORD);
   DCHECK(write_result);
   write_result = key.WriteValue(kRegistryValueCrxInstalledPath,
                                 path.value().c_str());
   DCHECK(write_result);
+
+  write_result = key.WriteValue(kRegistryValueCrxInstalledByVersion,
+                                LSTRINGIZE(CHROME_VERSION_STRING));

[twiz, 2010/11/15 19:02:48]

Add a DCHECK here too?

 }
 
 bool IsCrxOrEmpty(const std::wstring& path) {
   return (path.empty() ||
       (path.substr(std::max(path.size() - 4, 0u)) == L".crx"));
 }
 
 void SetOptionToolbandIsHidden(bool is_hidden) {
   SetCeeeRegistryBoolean(kRegistryValueToolbandIsHidden, is_hidden);
 }
@@ skipping 56 matching lines @@
   DWORD value;
   if (!key.ReadValueDW(google_update::kRegUsageStatsField, &value)) {
     base::win::RegKey hklm_key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_READ);
     if (!hklm_key.ReadValueDW(google_update::kRegUsageStatsField, &value))
       return false;
   }
   return (1 == value);
 }
 
 }  // namespace ceee_module_util