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 check whether
+//       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 <algorithm>
 #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 kChromeRegClientStateMediumKey[] =
+    L"Software\\Google\\Update\\ClientStateMedium\\"
+    L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
+
 const wchar_t kChromeRegLaunchCmd[] = L"InstallerSuccessLaunchCmdLine";
 const wchar_t kChromeRegLastLaunchCmd[] = L"LastInstallerSuccessLaunchCmdLine";
 const wchar_t kChromeRegVersion[] = L"pv";
 const wchar_t kNoChromeOfferUntil[] =
     L"SOFTWARE\\Google\\No Chrome Offer Until";
 
 // Return the company name specified in the file version info resource.
 bool GetCompanyName(const wchar_t* filename, wchar_t* buffer, DWORD out_len) {
   wchar_t file_version_info[8192];
   DWORD handle = 0;
@@ skipping 26 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 98 matching lines @@
       }
       delete[] token_user;
     }
     ::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) {
+BOOL __stdcall GoogleChromeCompatibilityCheck(BOOL set_flag, 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 13 matching lines @@
   if (local_reasons == 0 && !CanReOfferChrome(set_flag))
     local_reasons |= GCCC_ERROR_ALREADYOFFERED;
 
   // Done. Copy/return results.
   if (reasons != NULL)
     *reasons = local_reasons;
 
   return (local_reasons == 0);
 }
 
-#pragma comment(linker, "/EXPORT:LaunchGoogleChrome=_LaunchGoogleChrome@0,PRIVATE")
-DLLEXPORT BOOL __stdcall LaunchGoogleChrome() {
+BOOL __stdcall LaunchGoogleChrome() {
   wchar_t launch_cmd[MAX_PATH];
   size_t size = _countof(launch_cmd);
   if (!ReadValueFromRegistry(HKEY_LOCAL_MACHINE, kChromeRegClientStateKey,
                              kChromeRegLastLaunchCmd, launch_cmd, &size)) {
     size = _countof(launch_cmd);
     if (!ReadValueFromRegistry(HKEY_LOCAL_MACHINE, kChromeRegClientStateKey,
                                kChromeRegLaunchCmd, launch_cmd, &size)) {
       return false;
     }
   }
@@ skipping 72 matching lines @@
       ret = true;
     ipl.Release();
   }
 
   if (impersonation_success)
     ::RevertToSelf();
   ::CoUninitialize();
   return ret;
 }
 
-#pragma comment(linker, "/EXPORT:LaunchGoogleChromeWithDimensions=_LaunchGoogleChromeWithDimensions@16,PRIVATE")
-DLLEXPORT BOOL __stdcall LaunchGoogleChromeWithDimensions(int x,
-                                                          int y,
-                                                          int width,
-                                                          int height) {
+BOOL __stdcall LaunchGoogleChromeWithDimensions(int x,
+                                                int y,
+                                                int width,
+                                                int height) {
   if (!LaunchGoogleChrome())
     return false;
 
   HWND handle = NULL;
   int seconds_elapsed = 0;
 
   // Chrome may have been launched, but the window may not have appeared
   // yet. Wait for it to appear for 10 seconds, but exit if it takes longer
   // than that.
   while (!handle && seconds_elapsed < 10) {
@@ skipping 13 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));
 }
+
+int __stdcall GoogleChromeDaysSinceLastRun() {
+  using base::win::RegKey;
+  using base::Time;
+  using base::TimeDelta;
+
+  int days_since_last_run = std::numeric_limits<int>::max();
+
+  struct {
+    HKEY hive;
+    const wchar_t* path;
+  } reg_data[] = {
+    { HKEY_LOCAL_MACHINE, kChromeRegClientStateMediumKey },
+    { HKEY_CURRENT_USER, kChromeRegClientStateKey }
+  };
+
+  for (int i = 0; i < arraysize(reg_data); ++i) {
+    RegKey client_state(reg_data[i].hive, reg_data[i].path, KEY_QUERY_VALUE);

[grt (UTC plus 2), 2011/11/14 14:24:09]

i think this is prone to flakiness since it doesn't check for installation of
the product (install system-level chrome, run it once, uninstall it, install
user-level chrome.  this will give you the no-longer-present system-level
chrome's lastrun until Omaha cleans it up).  to be correct, it should look in
the Clients key for a "pv" value.  only if that is present should it look in
ClientStateMedium/ClientState.

[robertshield, 2011/11/14 15:13:49]

Done.

+    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;
+
+        // We can end up with negative numbers here, given changes in system
+        // clock time or due to TimeDelta's int64 -> int truncation.
+        int new_days_since_last_run = difference.InDays();
+        if (new_days_since_last_run >= 0) {

[grt (UTC plus 2), 2011/11/14 14:24:09]

heh.  now that you need this check anyway, i'd get rid of std::min and
<algorithm> and do:
if (new_days_since_last_run >= 0 && new_days_since_last_run <
days_since_last_run)
  days_since_last_run = new_days_since_last_run;

[robertshield, 2011/11/14 15:13:49]

Done.

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