Switch to standard integer types in gpu/.

gpu/command_buffer/service/framebuffer_manager.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 "gpu/command_buffer/service/framebuffer_manager.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/framebuffer_completeness_cache.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 
@@ skipping 45 matching lines @@
     return renderbuffer_.get() == renderbuffer;
   }
 
   bool CanRenderTo() const override { return true; }
 
   void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     // Nothing to do for renderbuffers.
   }
 
   bool ValidForAttachmentType(GLenum attachment_type,
-                              uint32 max_color_attachments) override {
-    uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
+                              uint32_t max_color_attachments) override {
+    uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
-    uint32 have = GLES2Util::GetChannelsForFormat(internal_format());
+    uint32_t have = GLES2Util::GetChannelsForFormat(internal_format());
     return (need & have) != 0;
   }
 
   Renderbuffer* renderbuffer() const {
     return renderbuffer_.get();
   }
 
   size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return renderbuffer_->GetSignatureSize();
   }
@@ skipping 94 matching lines @@
 
   bool CanRenderTo() const override {
     return texture_ref_->texture()->CanRenderTo();
   }
 
   void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     texture_ref_->texture()->DetachFromFramebuffer();
   }
 
   bool ValidForAttachmentType(GLenum attachment_type,
-                              uint32 max_color_attachments) override {
+                              uint32_t max_color_attachments) override {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
         target_, level_, &type, &internal_format)) {
       return false;
     }
-    uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
+    uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
-    uint32 have = GLES2Util::GetChannelsForFormat(internal_format);
+    uint32_t have = GLES2Util::GetChannelsForFormat(internal_format);
 
     // Workaround for NVIDIA drivers that incorrectly expose these formats as
     // renderable:
     if (internal_format == GL_LUMINANCE || internal_format == GL_ALPHA ||
         internal_format == GL_LUMINANCE_ALPHA) {
       return false;
     }
     return (need & have) != 0;
   }
 
@@ skipping 19 matching lines @@
   scoped_refptr<TextureRef> texture_ref_;
   GLenum target_;
   GLint level_;
   GLsizei samples_;
   GLint layer_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureAttachment);
 };
 
 FramebufferManager::FramebufferManager(
-    uint32 max_draw_buffers,
-    uint32 max_color_attachments,
+    uint32_t max_draw_buffers,
+    uint32_t max_color_attachments,
     ContextType context_type,
     const scoped_refptr<FramebufferCompletenessCache>&
         framebuffer_combo_complete_cache)
     : framebuffer_state_change_count_(1),
       framebuffer_count_(0),
       have_context_(true),
       max_draw_buffers_(max_draw_buffers),
       max_color_attachments_(max_color_attachments),
       context_type_(context_type),
       framebuffer_combo_complete_cache_(framebuffer_combo_complete_cache) {
@@ skipping 48 matching lines @@
     : manager_(manager),
       deleted_(false),
       service_id_(service_id),
       has_been_bound_(false),
       framebuffer_complete_state_count_id_(0),
       read_buffer_(GL_COLOR_ATTACHMENT0) {
   manager->StartTracking(this);
   DCHECK_GT(manager->max_draw_buffers_, 0u);
   draw_buffers_.reset(new GLenum[manager->max_draw_buffers_]);
   draw_buffers_[0] = GL_COLOR_ATTACHMENT0;
-  for (uint32 i = 1; i < manager->max_draw_buffers_; ++i)
+  for (uint32_t i = 1; i < manager->max_draw_buffers_; ++i)
     draw_buffers_[i] = GL_NONE;
 }
 
 Framebuffer::~Framebuffer() {
   if (manager_) {
     if (manager_->have_context_) {
       GLuint id = service_id();
       glDeleteFramebuffersEXT(1, &id);
     }
     manager_->StopTracking(this);
@@ skipping 20 matching lines @@
       const Attachment* attachment = it->second.get();
       if (!attachment->cleared())
         return true;
     }
   }
   return false;
 }
 
 void Framebuffer::ChangeDrawBuffersHelper(bool recover) const {
   scoped_ptr<GLenum[]> buffers(new GLenum[manager_->max_draw_buffers_]);
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i)
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i)
     buffers[i] = GL_NONE;
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     if (it->first >= GL_COLOR_ATTACHMENT0 &&
         it->first < GL_COLOR_ATTACHMENT0 + manager_->max_draw_buffers_ &&
         !GLES2Util::IsIntegerFormat(it->second->internal_format())) {
       buffers[it->first - GL_COLOR_ATTACHMENT0] = it->first;
     }
   }
   bool different = false;
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (buffers[i] != draw_buffers_[i]) {
       different = true;
       break;
     }
   }
   if (different) {
     if (recover)
       glDrawBuffersARB(manager_->max_draw_buffers_, draw_buffers_.get());
     else
       glDrawBuffersARB(manager_->max_draw_buffers_, buffers.get());
@@ skipping 191 matching lines @@
   return draw_buffers_[index];
 }
 
 void Framebuffer::SetDrawBuffers(GLsizei n, const GLenum* bufs) {
   DCHECK(n <= static_cast<GLsizei>(manager_->max_draw_buffers_));
   for (GLsizei i = 0; i < n; ++i)
     draw_buffers_[i] = bufs[i];
 }
 
 bool Framebuffer::HasAlphaMRT() const {
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (draw_buffers_[i] != GL_NONE) {
       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
       if (!attachment)
         continue;
       if ((GLES2Util::GetChannelsForFormat(
                attachment->internal_format()) & 0x0008) != 0)
         return true;
     }
   }
   return false;
 }
 
 bool Framebuffer::HasSameInternalFormatsMRT() const {
   GLenum internal_format = 0;
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (draw_buffers_[i] != GL_NONE) {
       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
       if (!attachment)
         continue;
       if (!internal_format) {
         internal_format = attachment->internal_format();
       } else if (internal_format != attachment->internal_format()) {
         return false;
       }
     }
@@ skipping 155 matching lines @@
 
 bool FramebufferManager::IsComplete(
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu