Mike's change.

chrome/installer/gcapi/gcapi.cc

 // Copyright (c) 2012 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.
 
@@ skipping 15 matching lines @@
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/installer/gcapi/gcapi_omaha_experiment.h"
 #include "chrome/installer/gcapi/gcapi_reactivation.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/util_constants.h"
-#include "google_update/google_update_idl.h"
+

[Roger Tawa OOO till Jul 10th, 2012/02/24 21:46:59]

why extra space?

[robertshield, 2012/02/24 22:21:40]

Done.

+#include "google_update/google_update_idl.h"  // NOLINT
 
 using base::Time;
 using base::TimeDelta;
 using base::win::RegKey;
 using base::win::ScopedCOMInitializer;
 using base::win::ScopedComPtr;
 using base::win::ScopedHandle;
 
 namespace {
 
@@ skipping 265 matching lines @@
       }
       delete[] token_user;
     }
     ::CloseHandle(process_token);
   }
   ::CloseHandle(process_handle);
   return result;
 }
 }  // namespace
 
-BOOL __stdcall GoogleChromeCompatibilityCheck(BOOL set_flag, DWORD* reasons) {
+BOOL __stdcall GoogleChromeCompatibilityCheck(BOOL set_flag,
+                                              int shell_mode,
+                                              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;
 
   if (IsChromeInstalled(HKEY_CURRENT_USER))
     local_reasons |= GCCC_ERROR_USERLEVELALREADYPRESENT;
 
-  if (!VerifyHKLMAccess()) {
+  if (shell_mode == GCAPI_INVOKED_UAC_ELEVATION) {
+    // Only check that we have HKLM write permissions if we specify that
+    // GCAPI is being invoked from an elevated shell, or in admin mode
+    if (!VerifyHKLMAccess()) {
     local_reasons |= GCCC_ERROR_ACCESSDENIED;
-  } else if ((windows_version == VERSION_VISTA_OR_HIGHER) &&
-             !VerifyAdminGroup()) {
+    } else if ((windows_version == VERSION_VISTA_OR_HIGHER) &&
+         !VerifyAdminGroup()) {
     // For Vista or later check for elevation since even for admin user we could
     // be running in non-elevated mode. We require integrity level High.
     local_reasons |= GCCC_ERROR_INTEGRITYLEVEL;
+    }
   }
 
   // Then only check whether we can re-offer, if everything else is OK.
   if (local_reasons == 0 && !CanReOfferChrome(set_flag))
     local_reasons |= GCCC_ERROR_ALREADYOFFERED;
 
   // Done. Copy/return results.
   if (reasons != NULL)
     *reasons = local_reasons;
 
@@ skipping 184 matching lines @@
   if (days_since_last_run == std::numeric_limits<int>::max()) {
     days_since_last_run = -1;
   }
 
   return days_since_last_run;
 }
 
 BOOL __stdcall CanOfferReactivation(const wchar_t* brand_code,
                                     int previous_brand_codes_length,
                                     const wchar_t** previous_brand_codes,
+                                    int shell_mode,
                                     DWORD* error_code) {
   DCHECK(error_code);
 
   if (!brand_code ||
       (previous_brand_codes_length > 0 && previous_brand_codes == NULL)) {
     if (error_code)
       *error_code = REACTIVATE_ERROR_INVALID_INPUT;
     return FALSE;
   }
 
   bool has_system_install = IsChromeInstalled(HKEY_LOCAL_MACHINE);
   bool has_user_install = IsChromeInstalled(HKEY_CURRENT_USER);
 
   if (!has_system_install && !has_user_install) {
     if (error_code)
       *error_code = REACTIVATE_ERROR_NOTINSTALLED;
     return FALSE;
   }
 
   int days_since_last_run = GoogleChromeDaysSinceLastRun();
   if (days_since_last_run >= 0 &&
       days_since_last_run < kReactivationMinDaysDormant) {
     if (error_code)
       *error_code = REACTIVATE_ERROR_NOTDORMANT;
     return FALSE;
   }
 
   // Make sure we haven't previously been reactivated by this brand code
   // or any of the previous brand codes from this partner.
-  std::vector<std::wstring> reactivation_brands;
-  reactivation_brands.push_back(brand_code);
-  if (previous_brand_codes_length > 0 && previous_brand_codes != NULL) {
+  // Since this function is invoked by ReactivateChrome, and since
+  // ReactivateChrome is called first in non-elevated shell and
+  // second in UAC-elevated shell, we only want to execute this block
+  // of code the first time, in non-elevated mode.
+  if (shell_mode == GCAPI_INVOKED_STANDARD_SHELL) {
+    std::vector<std::wstring> reactivation_brands;
+    reactivation_brands.push_back(brand_code);
+    if (previous_brand_codes_length > 0 && previous_brand_codes != NULL) {
     std::copy(previous_brand_codes,
-              previous_brand_codes + previous_brand_codes_length,
-              std::back_inserter(reactivation_brands));
-  }
-  if (HasBeenReactivatedByBrandCodes(reactivation_brands)) {
+          previous_brand_codes + previous_brand_codes_length,
+          std::back_inserter(reactivation_brands));

[Roger Tawa OOO till Jul 10th, 2012/02/24 21:46:59]

above: indent 4 more.

[robertshield, 2012/02/24 22:21:40]

Done.

+    }
+    if (HasBeenReactivatedByBrandCodes(reactivation_brands)) {
     if (error_code)
       *error_code = REACTIVATE_ERROR_ALREADY_REACTIVATED;
     return FALSE;

[Roger Tawa OOO till Jul 10th, 2012/02/24 21:46:59]

indent if(error_code) block

[robertshield, 2012/02/24 22:21:40]

Done.

+    }
   }
 
   return TRUE;
 }
 
 BOOL __stdcall ReactivateChrome(wchar_t* brand_code,
                                 int previous_brand_codes_length,
                                 const wchar_t** previous_brand_codes,
+                                int shell_mode,
                                 DWORD* error_code) {
   BOOL result = FALSE;
   if (CanOfferReactivation(brand_code,
                            previous_brand_codes_length,
                            previous_brand_codes,
+                           shell_mode,
                            error_code)) {
-    if (SetReactivationBrandCode(brand_code)) {
+    if (SetReactivationBrandCode(brand_code, shell_mode)) {
       // Currently set this as a best-effort thing. We return TRUE if
       // reactivation succeeded regardless of the experiment label result.
-      SetOmahaExperimentLabel(brand_code);
+      SetOmahaExperimentLabel(brand_code, shell_mode);
 
       result = TRUE;
     } else {
       if (error_code)
         *error_code = REACTIVATE_ERROR_REACTIVATION_FAILED;
     }
   }
 
   return result;
 }