Fix SyzyASAN build, by removing base/bits.h include.

base/allocator/winheap_stubs_win.cc

 // Copyright 2016 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.
 
 // This code should move into the default Windows shim once the win-specific
 // allocation shim has been removed, and the generic shim has becaome the
 // default.
 
 #include "winheap_stubs_win.h"
 
 #include <limits.h>
 #include <malloc.h>
 #include <new.h>
 #include <windows.h>
 
-#include "base/bits.h"
-
 namespace base {
 namespace allocator {
 
 bool g_is_win_shim_layer_initialized = false;
 
 namespace {
 
 const size_t kWindowsPageSize = 4096;
 const size_t kMaxWindowsAllocation = INT_MAX - kWindowsPageSize;
 
 inline HANDLE get_heap_handle() {
   return reinterpret_cast<HANDLE>(_get_heap_handle());
 }
 
+size_t Align(size_t size, size_t alignment) {

[Primiano Tucci (use gerrit), 2016/09/12 15:44:22]

At this point probably not worth having a separate function and just putting the
code down there will make everything more readable (down there you have the
comment that says "round up" which clears the ambiguity about the intent of this
function).
Having said that, not a huge deal at all.
Maybe do that only if you are really bored, or just tick commit otherwise.
Whateverz.

[Sigurður Ásgeirsson, 2016/09/12 17:15:22]

Done.

+  return (size + alignment - 1) & ~(alignment - 1);
+}
+
 }  // namespace
 
 void* WinHeapMalloc(size_t size) {
   if (size < kMaxWindowsAllocation)
     return HeapAlloc(get_heap_handle(), 0, size);
   return nullptr;
 }
 
 void WinHeapFree(void* size) {
   HeapFree(get_heap_handle(), 0, size);
@@ skipping 22 matching lines @@
   size += 8;
 
 // Round up to the nearest allocation granularity, which is 8 for
 // 32 bit machines, and 16 for 64 bit machines.
 #if defined(ARCH_CPU_64_BITS)
   const size_t kAllocationGranularity = 16;
 #else
   const size_t kAllocationGranularity = 8;
 #endif
 
-  return base::bits::Align(size, kAllocationGranularity);
+  return Align(size, kAllocationGranularity);
 }
 
 // Call the new handler, if one has been set.
 // Returns true on successfully calling the handler, false otherwise.
 bool WinCallNewHandler(size_t size) {
 #if !defined(_HAS_EXCEPTIONS) || _HAS_EXCEPTIONS
 #error "Exceptions in allocator shim are not supported!"
 #endif  // defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
   // Get the current new handler.
   _PNH nh = _query_new_handler();
   if (!nh)
     return false;
   // Since exceptions are disabled, we don't really know if new_handler
   // failed.  Assume it will abort if it fails.
   return nh(size) ? true : false;
 }
 
 }  // namespace allocator
 }  // namespace base