Fix a few lints found while working on crrev.com/1051503003.

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
+#include <queue>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/float_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 70 matching lines @@
                                      0.0f, 0.0f, 0.0f, 1.0f};
 
 static bool PrecisionMeetsSpecForHighpFloat(GLint rangeMin,
                                             GLint rangeMax,
                                             GLint precision) {
   return (rangeMin >= 62) && (rangeMax >= 62) && (precision >= 16);
 }
 
 static void GetShaderPrecisionFormatImpl(GLenum shader_type,
                                          GLenum precision_type,
-                                         GLint *range, GLint *precision) {
+                                         GLint* range, GLint* precision) {
   switch (precision_type) {
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
       // These values are for a 32-bit twos-complement integer format.
       range[0] = 31;
       range[1] = 30;
       *precision = 0;
       break;
     case GL_LOW_FLOAT:
@@ skipping 383 matching lines @@
     return id_;
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(BackFramebuffer);
 };
 
 struct FenceCallback {
-  explicit FenceCallback()
+  FenceCallback()
       : fence(gfx::GLFence::Create()) {
     DCHECK(fence);
   }
   std::vector<base::Closure> callbacks;
   scoped_ptr<gfx::GLFence> fence;
 };
 
 class AsyncUploadTokenCompletionObserver
     : public AsyncPixelTransferCompletionObserver {
  public:
@@ skipping 3778 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::ClearAllAttributes() const {
   // Must use native VAO 0, as RestoreAllAttributes can't fully restore
   // other VAOs.
   if (feature_info_->feature_flags().native_vertex_array_object)
     glBindVertexArrayOES(0);
 
   for (uint32 i = 0; i < group_->max_vertex_attribs(); ++i) {
-    if (i != 0) // Never disable attribute 0
+    if (i != 0)  // Never disable attribute 0
       glDisableVertexAttribArray(i);
-    if(features().angle_instanced_arrays)
+    if (features().angle_instanced_arrays)
       glVertexAttribDivisorANGLE(i, 0);
   }
 }
 
 void GLES2DecoderImpl::RestoreAllAttributes() const {
   state_.RestoreVertexAttribs();
 }
 
 void GLES2DecoderImpl::SetIgnoreCachedStateForTest(bool ignore) {
   state_.SetIgnoreCachedStateForTest(ignore);
@@ skipping 1350 matching lines @@
   GLenum impl_format =
       renderbuffer_manager()->InternalRenderbufferFormatToImplFormat(
           internalformat);
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(
       "glRenderbufferStorageMultisampleCHROMIUM");
   RenderbufferStorageMultisampleHelper(
       feature_info_.get(), target, samples, impl_format, width, height);
   GLenum error =
       LOCAL_PEEK_GL_ERROR("glRenderbufferStorageMultisampleCHROMIUM");
   if (error == GL_NO_ERROR) {
-
     if (workarounds().validate_multisample_buffer_allocation) {
       if (!VerifyMultisampleRenderbufferIntegrity(
           renderbuffer->service_id(), impl_format)) {
         LOCAL_SET_GL_ERROR(
             GL_OUT_OF_MEMORY,
             "glRenderbufferStorageMultisampleCHROMIUM", "out of memory");
         return;
       }
     }
 
@@ skipping 47 matching lines @@
 // This function validates the allocation of a multisampled renderbuffer
 // by clearing it to a key color, blitting the contents to a texture, and
 // reading back the color to ensure it matches the key.
 bool GLES2DecoderImpl::VerifyMultisampleRenderbufferIntegrity(
     GLuint renderbuffer, GLenum format) {
 
   // Only validate color buffers.
   // These formats have been selected because they are very common or are known
   // to be used by the WebGL backbuffer. If problems are observed with other
   // color formats they can be added here.
-  switch(format) {
+  switch (format) {
     case GL_RGB:
     case GL_RGB8:
     case GL_RGBA:
     case GL_RGBA8:
       break;
     default:
       return true;
   }
 
   GLint draw_framebuffer, read_framebuffer;
@@ skipping 145 matching lines @@
       if (workarounds().use_current_program_after_successful_link)
         glUseProgram(program->service_id());
       if (workarounds().clear_uniforms_before_first_program_use)
         program_manager()->ClearUniforms(program);
     }
   }
 
   // LinkProgram can be very slow.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
-};
+}
 
 void GLES2DecoderImpl::DoSamplerParameterfv(
     GLuint sampler, GLenum pname, const GLfloat* params) {
   DCHECK(params);
   glSamplerParameterf(sampler, pname, params[0]);
 }
 
 void GLES2DecoderImpl::DoSamplerParameteriv(
     GLuint sampler, GLenum pname, const GLint* params) {
   DCHECK(params);
@@ skipping 1769 matching lines @@
 
   state_.vertex_attrib_manager->SetDivisor(
       index,
       divisor);
   glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 template <typename pixel_data_type>
 static void WriteAlphaData(
-    void *pixels, uint32 row_count, uint32 channel_count,
+    void* pixels, uint32 row_count, uint32 channel_count,
     uint32 alpha_channel_index, uint32 unpadded_row_size,
     uint32 padded_row_size, pixel_data_type alpha_value) {
   DCHECK_GT(channel_count, 0U);
   DCHECK_EQ(unpadded_row_size % sizeof(pixel_data_type), 0U);
   uint32 unpadded_row_size_in_elements =
       unpadded_row_size / sizeof(pixel_data_type);
   DCHECK_EQ(padded_row_size % sizeof(pixel_data_type), 0U);
   uint32 padded_row_size_in_elements =
       padded_row_size / sizeof(pixel_data_type);
   pixel_data_type* dst =
@@ skipping 2492 matching lines @@
       LOG(ERROR) << "Context lost because SwapBuffers failed.";
       LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB);
     }
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
-void GLES2DecoderImpl::DoSwapInterval(int interval)
-{
+void GLES2DecoderImpl::DoSwapInterval(int interval) {
   context_->SetSwapInterval(interval);
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::EnableFeatureCHROMIUM& c =
       *static_cast<const gles2::cmds::EnableFeatureCHROMIUM*>(cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
@@ skipping 2213 matching lines @@
   }
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu