Add a UMA stat to track if the Browser blacklist is Set on the Renderer

chrome_elf/blacklist/blacklist.cc

 // Copyright 2013 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/blacklist/blacklist.h"
 
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "chrome_elf/blacklist/blacklist_interceptions.h"
@@ skipping 42 matching lines @@
 // processes to run on 64-bit versions of Windows).  This will return
 // WOW64_DISABLED for both "32-bit Chrome on 32-bit Windows" and "64-bit
 // Chrome on 64-bit Windows".  WOW64_UNKNOWN means "an error occurred", e.g.
 // the process does not have sufficient access rights to determine this.
 enum WOW64Status {
   WOW64_DISABLED,
   WOW64_ENABLED,
   WOW64_UNKNOWN,
 };
 
+// Record if the blacklist was successfully initialized so processes can easily
+// determine if the blacklist is enabled for them.
+bool g_blacklist_initialized = false;
+
 WOW64Status GetWOW64StatusForCurrentProcess() {
   typedef BOOL (WINAPI* IsWow64ProcessFunc)(HANDLE, PBOOL);
   IsWow64ProcessFunc is_wow64_process = reinterpret_cast<IsWow64ProcessFunc>(
       GetProcAddress(GetModuleHandle(L"kernel32.dll"), "IsWow64Process"));
   if (!is_wow64_process)
     return WOW64_DISABLED;
   BOOL is_wow64 = FALSE;
   if (!(*is_wow64_process)(GetCurrentProcess(), &is_wow64))
     return WOW64_UNKNOWN;
   return is_wow64 ? WOW64_ENABLED : WOW64_DISABLED;
@@ skipping 163 matching lines @@
   return (result == ERROR_SUCCESS);
 }
 
 int BlacklistSize() {
   int size = -1;
   while(blacklist::g_troublesome_dlls[++size] != NULL);
 
   return size;
 }
 
+bool IsBlacklistInitialized() {
+  return g_blacklist_initialized;
+}
+
 bool AddDllToBlacklist(const wchar_t* dll_name) {
   int blacklist_size = BlacklistSize();
   // We need to leave one space at the end for the null pointer.
   if (blacklist_size + 1 >= kTroublesomeDllsMaxCount)
     return false;
   for (int i=0; i < blacklist_size; ++i) {
     if (!_wcsicmp(g_troublesome_dlls[i], dll_name))
       return true;
   }
 
@@ skipping 61 matching lines @@
       thunk = new sandbox::Wow64W8ResolverThunk(current_process, kRelaxed);
     else
       thunk = new sandbox::Wow64ResolverThunk(current_process, kRelaxed);
   } else if (os_info.version() >= VERSION_WIN8) {
     thunk = new sandbox::Win8ResolverThunk(current_process, kRelaxed);
   } else {
     thunk = new sandbox::ServiceResolverThunk(current_process, kRelaxed);
   }
 #endif
 
+  // Record that we have initialized the blacklist.
+  g_blacklist_initialized = true;
+
   BYTE* thunk_storage = reinterpret_cast<BYTE*>(&g_thunk_storage);
 
   // Mark the thunk storage as readable and writeable, since we
   // ready to write to it.
   DWORD old_protect = 0;
   if (!VirtualProtect(&g_thunk_storage,
                       sizeof(g_thunk_storage),
                       PAGE_EXECUTE_READWRITE,
                       &old_protect))
     return false;
@@ skipping 15 matching lines @@
   // Mark the thunk storage as executable and prevent any future writes to it.
   BOOL page_executable = VirtualProtect(&g_thunk_storage,
                                         sizeof(g_thunk_storage),
                                         PAGE_EXECUTE_READ,
                                         &old_protect);
 
   return NT_SUCCESS(ret) && page_executable;
 }
 
 }  // namespace blacklist