Cleanup: avoid foo ? true : false, part 2.

sandbox/win/src/sandbox_nt_util.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 "sandbox/win/src/sandbox_nt_util.h"
 
 #include "base/win/pe_image.h"
 #include "sandbox/win/src/sandbox_factory.h"
 #include "sandbox/win/src/target_services.h"
 
 namespace sandbox {
 
 // This is the list of all imported symbols from ntdll.dll.
 SANDBOX_INTERCEPT NtExports g_nt = { NULL };
 
-}

[rvargas (doing something else), 2012/09/18 18:56:28]

I actually prefer if the anonymous namespace is not part of the sandbox
namespace.

[Lei Zhang, 2012/09/19 01:32:41]

Done.

-
 namespace {
 
 #if defined(_WIN64)
 void* AllocateNearTo(void* source, size_t size) {
-  using sandbox::g_nt;
-
   // Start with 1 GB above the source.
   const unsigned int kOneGB = 0x40000000;
   void* base = reinterpret_cast<char*>(source) + kOneGB;
   SIZE_T actual_size = size;
   ULONG_PTR zero_bits = 0;  // Not the correct type if used.
   ULONG type = MEM_RESERVE;
 
   if (reinterpret_cast<SIZE_T>(source) > 0x7ff80000000) {
     // We are at the top of the address space. Let's try the highest available
     // address.
@@ skipping 29 matching lines @@
   if (!NT_SUCCESS(ret)) {
     VERIFY_SUCCESS(g_nt.FreeVirtualMemory(NtCurrentProcess, &base, &size,
                                           MEM_RELEASE));
     base = NULL;
   }
 
   return base;
 }
 #else  // defined(_WIN64).
 void* AllocateNearTo(void* source, size_t size) {
-  using sandbox::g_nt;
   UNREFERENCED_PARAMETER(source);
 
   // In 32-bit processes allocations below 512k are predictable, so mark
   // anything in that range as reserved and retry until we get a good address.
   const void* const kMinAddress = reinterpret_cast<void*>(512 * 1024);
   NTSTATUS ret;
   SIZE_T actual_size;
   void* base;
   do {
     base = NULL;
     actual_size = 64 * 1024;
     ret = g_nt.AllocateVirtualMemory(NtCurrentProcess, &base, 0, &actual_size,
                                      MEM_RESERVE, PAGE_NOACCESS);
     if (!NT_SUCCESS(ret))
       return NULL;
   } while (base < kMinAddress);
 
   actual_size = size;
   ret = g_nt.AllocateVirtualMemory(NtCurrentProcess, &base, 0, &actual_size,
                                    MEM_COMMIT, PAGE_READWRITE);
   if (!NT_SUCCESS(ret))
     return NULL;
   return base;
 }
 #endif  // defined(_WIN64).
 
 }  // namespace.
 
-namespace sandbox {
-
 // Handle for our private heap.
 void* g_heap = NULL;
 
 SANDBOX_INTERCEPT HANDLE g_shared_section;
 SANDBOX_INTERCEPT size_t g_shared_IPC_size = 0;
 SANDBOX_INTERCEPT size_t g_shared_policy_size = 0;
 
 void* volatile g_shared_policy_memory = NULL;
 void* volatile g_shared_IPC_memory = NULL;
 
@@ skipping 45 matching lines @@
     // Create a new heap using default values for everything.
     void* heap = g_nt.RtlCreateHeap(HEAP_GROWABLE, NULL, 0, 0, NULL, NULL);
     if (!heap)
       return false;
 
     if (NULL != _InterlockedCompareExchangePointer(&g_heap, heap, NULL)) {
       // Somebody beat us to the memory setup.
       g_nt.RtlDestroyHeap(heap);
     }
   }
-  return (g_heap) ? true : false;
+  return (g_heap != NULL);
 }
 
 // Physically reads or writes from memory to verify that (at this time), it is
 // valid. Returns a dummy value.
 int TouchMemory(void* buffer, size_t size_bytes, RequiredAccess intent) {
   const int kPageSize = 4096;
   int dummy = 0;
   char* start = reinterpret_cast<char*>(buffer);
   char* end = start + size_bytes - 1;
 
@@ skipping 410 matching lines @@
   UNREFERENCED_PARAMETER(type);
   return buffer;
 }
 
 void __cdecl operator delete(void* memory, void* buffer,
                              sandbox::AllocationType type) {
   UNREFERENCED_PARAMETER(memory);
   UNREFERENCED_PARAMETER(buffer);
   UNREFERENCED_PARAMETER(type);
 }