Add functionality to the GCAPI to detect when Chrome was last run.

chrome/installer/gcapi/gcapi.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.
 
+// NOTE: This code is a legacy utility API for partners to checking whether

[grt (UTC plus 2), 2011/11/11 17:01:01]

checking -> check

[robertshield, 2011/11/12 05:25:38]

Done.

+//       Chrome can be installed and launched. Recent updates are being made
+//       to add new functionality. These updates use code from Chromium, the old
+//       coded against the win32 api directly. If you have an itch to shave a
+//       yak, feel free to re-write the old code too.
+
 #include "chrome/installer/gcapi/gcapi.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
-#include <windows.h>
 #include <sddl.h>
 #define STRSAFE_NO_DEPRECATE
 #include <strsafe.h>
 #include <tlhelp32.h>
+#include <windows.h>
 
 #include <cstdlib>
+#include <limits>
+#include <string>
 
-#include "google_update_idl.h"
+#include "base/basictypes.h"
+#include "base/string_number_conversions.h"
+#include "base/time.h"
+#include "base/win/registry.h"
+#include "chrome/installer/util/google_update_constants.h"
+
+#include "google_update_idl.h"  // NOLINT
 
 namespace {
 
 const wchar_t kChromeRegClientsKey[] =
     L"Software\\Google\\Update\\Clients\\"
     L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
 const wchar_t kChromeRegClientStateKey[] =
     L"Software\\Google\\Update\\ClientState\\"
     L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
 const wchar_t kChromeRegLaunchCmd[] = L"InstallerSuccessLaunchCmdLine";
@@ skipping 35 matching lines @@
   memcpy(&lang, data, 4);
   ::StringCchPrintf(info_name, _countof(info_name),
       L"\\StringFileInfo\\%02X%02X%02X%02X\\CompanyName",
       (lang & 0xff00)>>8, (lang & 0xff), (lang & 0xff000000)>>24,
       (lang & 0xff0000)>>16);
 
   data_len = 0;
   if (!::VerQueryValue(file_version_info, info_name,
       reinterpret_cast<LPVOID *>(&data), reinterpret_cast<UINT *>(&data_len)))
     return false;
-  if (data_len <= 0 || data_len >= out_len)
+  if (data_len <= 0 || data_len >= (out_len / sizeof(wchar_t)))
     return false;
 
   memset(buffer, 0, out_len);
-  ::StringCchCopyN(buffer, out_len, (const wchar_t*)data, data_len);
+  ::StringCchCopyN(buffer,
+                   (out_len / sizeof(wchar_t)),
+                   reinterpret_cast<const wchar_t*>(data),
+                   data_len);
   return true;
 }
 
 // Return true if we can re-offer Chrome; false, otherwise.
 // Each partner can only offer Chrome once every six months.
 bool CanReOfferChrome(BOOL set_flag) {
   wchar_t filename[MAX_PATH+1];
   wchar_t company[MAX_PATH];
 
   // If we cannot retrieve the version info of the executable or company
@@ skipping 45 matching lines @@
     }
 
     ::RegCloseKey(key);
   }
 
   return can_re_offer;
 }
 
 // Helper function to read a value from registry. Returns true if value
 // is read successfully and stored in parameter value. Returns false otherwise.
-bool ReadValueFromRegistry(HKEY root_key, const wchar_t *sub_key,
-                           const wchar_t *value_name, wchar_t *value,
-                           size_t *size) {
+bool ReadValueFromRegistry(HKEY root_key, const wchar_t* sub_key,
+                           const wchar_t* value_name, wchar_t* value,
+                           size_t* size) {
   HKEY key;
   if ((::RegOpenKeyEx(root_key, sub_key, NULL,
                       KEY_READ, &key) == ERROR_SUCCESS) &&
       (::RegQueryValueEx(key, value_name, NULL, NULL,
                          reinterpret_cast<LPBYTE>(value),
                          reinterpret_cast<LPDWORD>(size)) == ERROR_SUCCESS)) {
     ::RegCloseKey(key);
     return true;
   }
   return false;
 }
 
 bool IsChromeInstalled(HKEY root_key) {
   wchar_t version[64];
   size_t size = _countof(version);
   return ReadValueFromRegistry(root_key, kChromeRegClientsKey,
                                kChromeRegVersion, version, &size);
 }
 
 enum WindowsVersion {
   VERSION_BELOW_XP_SP2,
-  VERSION_XP_SP2_UP_TO_VISTA, // "but not including"
+  VERSION_XP_SP2_UP_TO_VISTA,  // "but not including"
   VERSION_VISTA_OR_HIGHER,
 };
 WindowsVersion GetWindowsVersion() {
   OSVERSIONINFOEX version_info = { sizeof version_info };
   GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&version_info));
 
   // Windows Vista is version 6.0.
   if (version_info.dwMajorVersion >= 6)
     return VERSION_VISTA_OR_HIGHER;
 
@@ skipping 100 matching lines @@
     }
     ::CloseHandle(process_token);
   }
   ::CloseHandle(process_handle);
   return result;
 }
 }  // namespace
 
 #pragma comment(linker, "/EXPORT:GoogleChromeCompatibilityCheck=_GoogleChromeCompatibilityCheck@8,PRIVATE")
 DLLEXPORT BOOL __stdcall GoogleChromeCompatibilityCheck(BOOL set_flag,
-                                                        DWORD *reasons) {
+                                                        DWORD* reasons) {
   DWORD local_reasons = 0;
 
   WindowsVersion windows_version = GetWindowsVersion();
   // System requirements?
   if (windows_version == VERSION_BELOW_XP_SP2)
     local_reasons |= GCCC_ERROR_OSNOTSUPPORTED;
 
   if (IsChromeInstalled(HKEY_LOCAL_MACHINE))
     local_reasons |= GCCC_ERROR_SYSTEMLEVELALREADYPRESENT;
 
@@ skipping 145 matching lines @@
   // This loop iterates through all of the top-level Windows named
   // Chrome_WindowImpl_0, and looks for the first one with any children.
   while (handle && !FindWindowEx(handle, NULL, L"Chrome_WindowImpl_0", NULL)) {
     // Get the next top-level Chrome window.
     handle = FindWindowEx(NULL, handle, L"Chrome_WindowImpl_0", NULL);
   }
 
   return (handle &&
           SetWindowPos(handle, 0, x, y, width, height, SWP_NOZORDER));
 }
+
+#pragma comment(linker, "/EXPORT:LaunchGoogleChromeWithDimensions=_LaunchGoogleChromeWithDimensions@24,PRIVATE")

[grt (UTC plus 2), 2011/11/11 17:01:01]

LaunchGoogleChromeWithDimensions -> GoogleChromeDaysSinceLastRun

[robertshield, 2011/11/12 05:25:38]

heh, done

+DLLEXPORT int __stdcall GoogleChromeDaysSinceLastRun() {
+  using base::win::RegKey;
+  using base::Time;
+  using base::TimeDelta;
+
+  int days_since_last_run = std::numeric_limits<int>::max();
+
+  HKEY hives[] = {HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER};

[grt (UTC plus 2), 2011/11/11 17:01:01]

Chrome doesn't even try to write to HKLM since it doesn't run elevated; see
http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/chrome/installer/util....

[robertshield, 2011/11/12 05:25:38]

so, as discussed modified this to assume that one day Chrome will write to HKLM
under ClientStateMedium, Chrome side change coming separately.

+  for (int i = 0; i < arraysize(hives); ++i) {
+    RegKey client_state(hives[i],
+                        kChromeRegClientStateKey,
+                        KEY_QUERY_VALUE);
+    if (client_state.Valid()) {
+      std::wstring last_run;
+      int64 last_run_value = 0;
+      if (client_state.ReadValue(google_update::kRegLastRunTimeField,
+                                 &last_run) == ERROR_SUCCESS &&
+          base::StringToInt64(last_run, &last_run_value)) {
+        Time last_run_time = Time::FromInternalValue(last_run_value);
+        TimeDelta difference = Time::NowFromSystemTime() - last_run_time;
+        int days_elapsed = difference.InDays();

[grt (UTC plus 2), 2011/11/11 17:01:01]

include <algorithm> and replace these four lines with:
days_since_last_run = std::min(difference.InDays(),  days_since_last_run);
?

[robertshield, 2011/11/12 05:25:38]

Done.

+        if (days_elapsed < days_since_last_run) {
+          days_since_last_run = days_elapsed;
+        }
+      }
+    }
+  }
+
+  if (days_since_last_run == std::numeric_limits<int>::max()) {
+    days_since_last_run = -1;
+  }
+
+  return days_since_last_run;
+}