Implement base::win::IsMetroProcess.

base/win/metro.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.
 
 #include "base/win/metro.h"
 
 #include "base/string_util.h"
 
 namespace base {
 namespace win {
 
 const char kActivateApplication[] = "ActivateApplication";
 
 HMODULE GetMetroModule() {
-  return GetModuleHandleA("metro_driver.dll");
+  const HMODULE kNoMetroDriver = reinterpret_cast<HMODULE>(1);

[Mark Mentovai, 2012/06/18 15:40:22]

Optional but highly recommended:

I think that this is kind of hackish.

I’ve been encouraging people to write helper functions and use them in static
initializers, leveraging the automatic guard variable to prevent multiple
initialization. That’d look like:

static HMODULE GetMetroModuleInternal() {  // or anonymous namespace
  HMODULE metro_module = GetModuleHandleA("metro_driver.dll");
  if (metro_module) {
    DCHECK(IsMetroProcess());
  }
  return metro_module;
}

HMODULE GetMetroModule() {
  static HMODULE metro_module = GetMetroModuleInternal();
  return metro_module;
}

Less source code, less object code, and a clearer design too. Win-win!

[Sigurður Ásgeirsson, 2012/06/18 18:51:13]

Sadly, as we discussed, VS does not implement thread-safe initialization of
local statics, so this would lead to a race here.
For posterity, I compiled this stub with VS2010: 

extern int foo();
int bar() {
  static int cache = foo();

  return cache;
}

and got the below thread-unsafe object code.

?bar@@YAHXZ (int __cdecl bar(void)):
  00000000: B8 01 00 00 00     mov         eax,1
  00000005: 84 05 00 00 00 00  test        byte ptr [?$S1@?1??bar@@YAHXZ@4IA],al

  0000000B: 75 11              jne         0000001E
  0000000D: 09 05 00 00 00 00  or          dword ptr
[?$S1@?1??bar@@YAHXZ@4IA],eax
  00000013: E8 00 00 00 00     call        ?foo@@YAHXZ
  00000018: A3 00 00 00 00     mov         dword ptr
[?cache@?1??bar@@YAHXZ@4HA],eax
  0000001D: C3                 ret
  0000001E: A1 00 00 00 00     mov         eax,dword ptr
[?cache@?1??bar@@YAHXZ@4HA]
  00000023: C3                 ret

+  static HMODULE metro_module = NULL;
+
+  if (metro_module == NULL) {
+    HMODULE module = GetModuleHandleA("metro_driver.dll");
+
+    if (module == NULL) {
+      metro_module = kNoMetroDriver;
+    } else {
+      // We must be in a metro process if the metro_driver is loaded.

[Mark Mentovai, 2012/06/18 15:40:22]

All four of your comments in this file say “we,” I prefer clearer and more
direct prose by avoiding personal pronouns.

[Sigurður Ásgeirsson, 2012/06/18 18:51:13]

Done.

+      DCHECK(IsMetroProcess());
+      metro_module = module;
+    }
+  }
+  DCHECK(metro_module != NULL);
+
+  if (metro_module == kNoMetroDriver)
+    return NULL;
+
+  return metro_module;
+}
+
+bool IsMetroProcess() {

[Mark Mentovai, 2012/06/18 15:40:22]

I’d follow the same pattern for this function too, which lets you give up the
enum in favor of a simple bool.

[Sigurður Ásgeirsson, 2012/06/18 18:51:13]

Same issue, sadly.

+  enum ImmersiveState {
+    kImmersiveUnknown,
+    kImmersiveTrue,
+    kImmersiveFalse
+  };
+  typedef BOOL (WINAPI* IsImmersiveProcessFunc)(HANDLE process);
+
+  // Since the immersive state of a process can never change, we look it
+  // up once and then cache it here.
+  static ImmersiveState state = kImmersiveUnknown;
+
+  if (state == kImmersiveUnknown) {
+    // We didn't look it up yet. Note that the code below here is idempotent,
+    // so it doesn't matter if it races to assignment on multiple threads.
+    HMODULE user32 = ::GetModuleHandleA("user32.dll");
+    DCHECK(user32 != NULL);
+
+    IsImmersiveProcessFunc is_immersive_process =
+        reinterpret_cast<IsImmersiveProcessFunc>(
+            ::GetProcAddress(user32, "IsImmersiveProcess"));
+
+    if (is_immersive_process != NULL) {
+      if (is_immersive_process(::GetCurrentProcess())) {
+        state = kImmersiveTrue;
+      } else {
+        state = kImmersiveFalse;
+      }
+    } else {
+      // No "IsImmersiveProcess" export on user32.dll, so we're pre-windows8
+      // and therefore not immersive.
+      state = kImmersiveFalse;
+    }
+  }
+  DCHECK_NE(kImmersiveUnknown, state);
+
+  return state == kImmersiveTrue;
 }
 
 wchar_t* LocalAllocAndCopyString(const string16& src) {
   size_t dest_size = (src.length() + 1) * sizeof(wchar_t);
   wchar_t* dest = reinterpret_cast<wchar_t*>(LocalAlloc(LPTR, dest_size));
   base::wcslcpy(dest, src.c_str(), dest_size);
   return dest;
 }
 
 }  // namespace win
 }  // namespace base