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

chrome_elf/chrome_elf_util.cc

Index: chrome_elf/chrome_elf_util.cc
diff --git a/chrome_elf/chrome_elf_util.cc b/chrome_elf/chrome_elf_util.cc
index a547d0bda04730b73f6c50dd6bb5ed3118dda50b..b385dd0e154875f5794f0374a9156ff090f7ca8e 100644
--- a/chrome_elf/chrome_elf_util.cc
+++ b/chrome_elf/chrome_elf_util.cc
@@ -193,17 +193,23 @@ bool ReportingIsEnforcedByPolicy(bool* breakpad_enabled) {
 }
 
 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();
-
-  // 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");
-
+  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();
+    has_process_type_flag = command_line && wcsstr(command_line, L"--type");
+    initialized = true;
+  }
   return (has_process_type_flag || is_sandboxed_process);
 }