Return Windows error code when create-process fails.

chrome/installer/mini_installer/mini_installer.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.
 
 // mini_installer.exe is the first exe that is run when chrome is being
 // installed or upgraded. It is designed to be extremely small (~5KB with no
 // extra resources linked) and it has two main jobs:
 //   1) unpack the resources (possibly decompressing some)
 //   2) run the real installer (setup.exe) with appropriate flags.
 //
@@ skipping 56 matching lines @@
   // Read a REG_SZ value from the registry into the memory indicated by |value|
   // (of |value_size| wchar_t units).  Returns ERROR_SUCCESS,
   // ERROR_FILE_NOT_FOUND, ERROR_MORE_DATA, or some other error.  |value| is
   // guaranteed to be null-terminated on success.
   LONG ReadValue(const wchar_t* value_name,
                  wchar_t* value,
                  size_t value_size) const;
 
   // Write a REG_SZ value to the registry.  |value| must be null-terminated.
   // Returns ERROR_SUCCESS or an error code.
   LONG WriteValue(const wchar_t* value_name, const wchar_t* value);

[grt (UTC plus 2), 2015/07/24 14:49:10]

some suggestions:
- change this to WriteSZValue
- change WriteDword to WriteDWValue

[bcwhite, 2015/07/24 17:08:01]

Done.

+  LONG WriteDword(const wchar_t* value_name, DWORD value);
 
   // Closes the key if it was open.
   void Close();
 
  private:
   RegKey(const RegKey&);
   RegKey& operator=(const RegKey&);
 
   HKEY key_;
 };  // class RegKey
@@ skipping 25 matching lines @@
   }
   return result;
 }
 
 LONG RegKey::WriteValue(const wchar_t* value_name, const wchar_t* value) {
   return ::RegSetValueEx(key_, value_name, 0, REG_SZ,
                          reinterpret_cast<const BYTE*>(value),
                          (lstrlen(value) + 1) * sizeof(wchar_t));
 }
 
+LONG RegKey::WriteDword(const wchar_t* value_name, DWORD value) {
+  return ::RegSetValueEx(key_, value_name, 0, REG_DWORD,
+                         reinterpret_cast<const BYTE*>(&value),
+                         sizeof(value));
+}
+
 void RegKey::Close() {
   if (key_ != NULL) {
     ::RegCloseKey(key_);
     key_ = NULL;
   }
 }
 
 // Helper function to read a value from registry. Returns true if value
 // is read successfully and stored in parameter value. Returns false otherwise.
 // |size| is measured in wchar_t units.
@@ skipping 746 matching lines @@
   // we don't need anymore.  Let's give it back to the pool before running
   // setup.
   ::SetProcessWorkingSetSize(::GetCurrentProcess(), -1, -1);
 
   if (exit_code == SUCCESS_EXIT_CODE)
     exit_code = RunSetup(configuration, archive_path.get(), setup_path.get());
 
   if (ShouldDeleteExtractedFiles())
     DeleteExtractedFiles(base_path.get(), archive_path.get(), setup_path.get());
 
+  const HKEY root_key =

[grt (UTC plus 2), 2015/07/24 14:49:11]

please move this into a helper function (WriteInstallerResults?) and wrap the
call to it in #if defined(GOOGLE_CHROME_BUILD) since Google Update integration
is not supported for Chromium.

[bcwhite, 2015/07/24 17:08:01]

Done.

+      configuration.is_system_level() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+  const wchar_t* app_guid = configuration.chrome_app_guid();

[grt (UTC plus 2), 2015/07/24 14:49:11]

this and SetInstallerFlags need to use the same ClientState key. please factor
the search logic out of SetInstallerFlags somehow so that they use the same key.
one way would be to make a helper that takes a Configuration as input and
returns the app_guid to be used for interactions with Google Update. Then that
app_guid can be passed to both SetInstallerFlags and WriteInstallerResults.

[bcwhite, 2015/07/24 17:08:01]

Done.  Complicated logic, though.  Please check thoroughly.

+  const REGSAM key_access = KEY_QUERY_VALUE | KEY_SET_VALUE;

[grt (UTC plus 2), 2015/07/24 14:49:11]

looks like KEY_QUERY_VALUE isn't needed here.

+  RegKey key;
+  if (OpenClientStateKey(root_key, app_guid, key_access, &key)) {
+    key.WriteDword(kInstallerResultRegistryValue,
+                   exit_code ? 1 /* FAILED_CUSTOM_ERROR */ : 0 /* SUCCESS */);
+    key.WriteDword(kInstallerErrorRegistryValue, exit_code);
+    key.WriteDword(kInstallerExtraCode1RegistryValue, ::GetLastError());

[grt (UTC plus 2), 2015/07/24 14:49:11]

GetLastError must be called immediately after a failed call to provide a useful
result.

[bcwhite, 2015/07/24 17:08:01]

Weird.  I wrote that for initial testing and changed it in a later commit.  Must
not have gotten sync'd to my office machine from where I did the upload.

+    key.Close();
+  }
+
   return exit_code;
 }
 
 }  // namespace mini_installer
 
 int MainEntryPoint() {
   mini_installer::ProcessExitCode result =
       mini_installer::WMain(::GetModuleHandle(NULL));
+
   ::ExitProcess(result);
 }
 
 // VC Express editions don't come with the memset CRT obj file and linking to
 // the obj files between versions becomes a bit problematic. Therefore,
 // simply implement memset.
 //
 // This also avoids having to explicitly set the __sse2_available hack when
 // linking with both the x64 and x86 obj files which is required when not
 // linking with the std C lib in certain instances (including Chromium) with
 // MSVC.  __sse2_available determines whether to use SSE2 intructions with
 // std C lib routines, and is set by MSVC's std C lib implementation normally.
 extern "C" {
 #pragma function(memset)
 void* memset(void* dest, int c, size_t count) {
   void* start = dest;
   while (count--) {
     *reinterpret_cast<char*>(dest) = static_cast<char>(c);
     dest = reinterpret_cast<char*>(dest) + 1;
   }
   return start;
 }
 }  // extern "C"