Cache IsNonBrowserProcess values, so we only take a loader-lock the first time.

chrome_elf/chrome_elf_util.cc

 // Copyright 2014 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.
 
 #include "chrome_elf/chrome_elf_util.h"
 
 #include <windows.h>
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
@@ skipping 175 matching lines @@
       *breakpad_enabled = value != 0;
     }
     ::RegCloseKey(key);
     return size == sizeof(value);
   }
 
   return false;
 }
 
 bool IsNonBrowserProcess() {
-  typedef bool (*IsSandboxedProcessFunc)();
-  IsSandboxedProcessFunc is_sandboxed_process_func =
-      reinterpret_cast<IsSandboxedProcessFunc>(
-          GetProcAddress(GetModuleHandle(NULL), "IsSandboxedProcess"));
-  bool is_sandboxed_process =
-      is_sandboxed_process_func && is_sandboxed_process_func();
+  static bool initialized = false;
+  // Assume a non-browser process until proven otherwise.
+  static bool is_sandboxed_process = true;
+  static bool has_process_type_flag = true;
+  if (!initialized) {

[Sigurður Ásgeirsson, 2015/05/08 14:36:33]

This mode of initialization is not thread safe. It can return bogus results on
concurrent invocations.

[grt (UTC plus 2), 2015/05/08 14:44:22]

In practice, I think that the first call will be during a single-threaded state.
Is there a way to assert this without adding a lock here? Otherwise, do you
suggest using a leaky LazyInstance?

[Sigurður Ásgeirsson, 2015/05/08 16:59:42]

If you can guarantee that this function is invoked at some particular time,
there's no need for locking, but that seems brittle to maintenance?

Maybe it's better to simply compute the value at some particular time, store it
in a "global" and return it from this function? This function can then simply
assert on this value having been initialized?

+    typedef bool (*IsSandboxedProcessFunc)();
+    IsSandboxedProcessFunc is_sandboxed_process_func =
+        reinterpret_cast<IsSandboxedProcessFunc>(
+            GetProcAddress(GetModuleHandle(NULL), "IsSandboxedProcess"));
+    is_sandboxed_process =

[grt (UTC plus 2), 2015/05/08 04:44:34]

if this is true, there's no need to check the command line, is there? how about
only keeping one piece of state rather than two and short-circuiting? for
example:
  static enum {
    UNINITIALIZED,
    NON_BROWSER_PROCESS,
    BROWSER_PROCESS,
  } result = UNINITIALIZED;
  while (result == UNINITIALIZED) {
    ... GetProcAddress
    if (is_sandboxed_process_func && is_sandboxed_process_func()) {
      result = NON_BROWSER_PROCESS;
      break;
    }
    const wchar_t* command_line = GetCommandLine();
    if (command_line && wcsstr(command_line, L"--type") {
      result = NON_BROWSER_PROCESS;
      break;
    }
    result = BROWSER_PROCESS;
    break;
  }
  return result == NON_BROWSER_PROCESS;

+        is_sandboxed_process_func && is_sandboxed_process_func();
 
-  // TODO(robertshield): Drop the command line check when we drop support for
-  // enabling chrome_elf in unsandboxed processes.
-  wchar_t* command_line = GetCommandLine();
-  bool has_process_type_flag = command_line && wcsstr(command_line, L"--type");
-
+    // TODO(robertshield): Drop the command line check when we drop support for
+    // enabling chrome_elf in unsandboxed processes.
+    wchar_t* command_line = GetCommandLine();
+    has_process_type_flag = command_line && wcsstr(command_line, L"--type");
+    initialized = true;
+  }
   return (has_process_type_flag || is_sandboxed_process);
 }