Mark memory_watcher as chromium_code.

tools/memory_watcher/memory_hook.cc

 // Copyright (c) 2006-2008 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.
 
 // Static class for hooking Win32 API routines.
 
 // Some notes about how to hook Memory Allocation Routines in Windows.
 //
 // For our purposes we do not hook the libc routines.  There are two
 // reasons for this.  First, the libc routines all go through HeapAlloc
@@ skipping 199 matching lines @@
 }
 
 static LPVOID WINAPI Perftools_HeapReAlloc(HANDLE hHeap, DWORD dwFlags,
                                            LPVOID lpMem, SIZE_T dwBytes) {
   // Don't call realloc, but instead do a free/malloc.  The problem is that
   // the builtin realloc may either expand a buffer, or it may simply
   // just call free/malloc.  If so, we will already have tracked the new
   // block via Perftools_HeapAlloc.
 
   LPVOID rv = Perftools_HeapAlloc(hHeap, dwFlags, dwBytes);
-  DCHECK_EQ((HEAP_REALLOC_IN_PLACE_ONLY & dwFlags), 0);
+  DCHECK_EQ((HEAP_REALLOC_IN_PLACE_ONLY & dwFlags), 0u);
 
   // If there was an old buffer, now copy the data to the new buffer.
   if (lpMem != 0) {
     size_t size = HeapSize(hHeap, 0, lpMem);
     if (size > dwBytes)
       size = dwBytes;
     // Note: size could be 0; HeapAlloc does allocate 0 length buffers.
     memcpy(rv, lpMem, size);
     Perftools_HeapFree(hHeap, dwFlags, lpMem);
   }
@@ skipping 28 matching lines @@
   return result;
 }
 
 static BOOL WINAPI Perftools_VirtualFreeEx(HANDLE process, LPVOID address,
                                            SIZE_T size, DWORD type) {
   int chunk_size = size;
   MEMORY_BASIC_INFORMATION info;
   CHECK(VirtualQuery(address, &info, sizeof(info)));
   if (chunk_size == 0)
     chunk_size = info.RegionSize;
-  bool decommit = (info.State & MEM_COMMIT);
+  bool decommit = (info.State & MEM_COMMIT) != 0;
 
   if (decommit)
       MemoryHook::hook()->OnUntrack(0, reinterpret_cast<int32>(address),
                                      chunk_size);
 
   return patch_VirtualFreeEx()(process, address, size, type);
 }
 
 static base::Lock known_maps_lock;
 static std::map<void*, int> known_maps;
@@ skipping 273 matching lines @@
 }
 
 void MemoryHook::OnUntrack(HANDLE heap, int32 id, int32 size) {
   // Don't notify about allocations to our internal heap.
   if (heap == heap_)
     return;
 
   if (watcher_)
     watcher_->OnUntrack(heap, id, size);
 }