Switch to standard integer types in content/.

content/child/child_shared_bitmap_manager.cc

 // Copyright (c) 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 "content/child/child_shared_bitmap_manager.h"
 
+#include <stddef.h>
+
 #include "base/debug/alias.h"
 #include "base/process/memory.h"
 #include "base/process/process_metrics.h"
+#include "build/build_config.h"
 #include "content/child/child_thread_impl.h"
 #include "content/common/child_process_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 namespace {
 
 class ChildSharedBitmap : public SharedMemoryBitmap {
  public:
   ChildSharedBitmap(scoped_refptr<ThreadSafeSender> sender,
                     base::SharedMemory* shared_memory,
                     const cc::SharedBitmapId& id)
-      : SharedMemoryBitmap(static_cast<uint8*>(shared_memory->memory()),
+      : SharedMemoryBitmap(static_cast<uint8_t*>(shared_memory->memory()),
                            id,
                            shared_memory),
         sender_(sender) {}
 
   ChildSharedBitmap(scoped_refptr<ThreadSafeSender> sender,
                     scoped_ptr<base::SharedMemory> shared_memory_holder,
                     const cc::SharedBitmapId& id)
       : ChildSharedBitmap(sender, shared_memory_holder.get(), id) {
     shared_memory_holder_ = shared_memory_holder.Pass();
   }
@@ skipping 26 matching lines @@
   base::debug::Alias(&height);
   base::debug::Alias(&last_error);
   base::debug::Alias(&private_bytes);
   base::debug::Alias(&shared_bytes);
 #endif
   base::TerminateBecauseOutOfMemory(alloc_size);
 }
 
 }  // namespace
 
-SharedMemoryBitmap::SharedMemoryBitmap(uint8* pixels,
+SharedMemoryBitmap::SharedMemoryBitmap(uint8_t* pixels,
                                        const cc::SharedBitmapId& id,
                                        base::SharedMemory* shared_memory)
-    : SharedBitmap(pixels, id), shared_memory_(shared_memory) {
-}
+    : SharedBitmap(pixels, id), shared_memory_(shared_memory) {}
 
 ChildSharedBitmapManager::ChildSharedBitmapManager(
     scoped_refptr<ThreadSafeSender> sender)
     : sender_(sender) {
 }
 
 ChildSharedBitmapManager::~ChildSharedBitmapManager() {}
 
 scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::AllocateSharedBitmap(
     const gfx::Size& size) {
@@ skipping 53 matching lines @@
   if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
     return scoped_ptr<cc::SharedBitmap>();
 #endif
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       mem->mapped_size(), handle_to_send, id));
 
   return make_scoped_ptr(new ChildSharedBitmap(sender_, mem, id));
 }
 
 }  // namespace content