GPU: Fix some linter errors.

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>
@@ skipping 65 matching lines @@
 
 namespace {
 
 static const char kOESDerivativeExtension[] = "GL_OES_standard_derivatives";
 
 khronos_uint64_t CityHashForAngle(const char* name, unsigned int len) {
   return static_cast<khronos_uint64_t>(
       CityHash64(name, static_cast<size_t>(len)));
 }
 
-}
+}  // namespace
 
 class GLES2DecoderImpl;
 
 // Check that certain assumptions the code makes are true. There are places in
 // the code where shared memory is passed direclty to GL. Example, glUniformiv,
 // glShaderSource. The command buffer code assumes GLint and GLsizei (and maybe
 // a few others) are 32bits. If they are not 32bits the code will have to change
 // to call those GL functions with service side memory and then copy the results
 // to shared memory, converting the sizes.
 COMPILE_ASSERT(sizeof(GLint) == sizeof(uint32),  // NOLINT
@@ skipping 1023 matching lines @@
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glClear
   error::Error DoClear(GLbitfield mask);
 
   // Wrappers for various state.
   void DoDepthRangef(GLclampf znear, GLclampf zfar);
   void DoHint(GLenum target, GLenum mode);
-  void DoSampleCoverage (GLclampf value, GLboolean invert);
+  void DoSampleCoverage(GLclampf value, GLboolean invert);
 
   // Wrapper for glCompileShader.
   void DoCompileShader(GLuint shader);
 
   // Helper for DeleteSharedIdsCHROMIUM commands.
   void DoDeleteSharedIdsCHROMIUM(
       GLuint namespace_id, GLsizei n, const GLuint* ids);
 
   // Wrapper for glDetachShader
   void DoDetachShader(GLuint client_program_id, GLint client_shader_id);
@@ skipping 2849 matching lines @@
           *params = 0;
         }
       }
       return true;
     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
       *num_written = 1;
       if (params) {
         if (state_.vertex_attrib_manager->element_array_buffer()) {
           GLuint client_id = 0;
           buffer_manager()->GetClientId(
-              state_.vertex_attrib_manager->element_array_buffer(
-                  )->service_id(), &client_id);
+              state_.vertex_attrib_manager->element_array_buffer()->
+                  service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_FRAMEBUFFER_BINDING:
     // case GL_DRAW_FRAMEBUFFER_BINDING_EXT: (same as GL_FRAMEBUFFER_BINDING)
       *num_written = 1;
       if (params) {
@@ skipping 558 matching lines @@
       break;
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
       state_.hint_fragment_shader_derivative = mode;
       break;
     default:
       NOTREACHED();
   }
   glHint(target, mode);
 }
 
-void GLES2DecoderImpl::DoSampleCoverage (GLclampf value, GLboolean invert) {
+void GLES2DecoderImpl::DoSampleCoverage(GLclampf value, GLboolean invert) {
   state_.sample_coverage_value = std::min(1.0f, std::max(0.0f, value));
   state_.sample_coverage_invert = (invert != 0);
   glSampleCoverage(state_.sample_coverage_value, invert);
 }
 
 // Assumes framebuffer is complete.
 void GLES2DecoderImpl::ClearUnclearedAttachments(
     GLenum target, FramebufferManager::FramebufferInfo* info) {
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     // bind this to the DRAW point, clear then bind back to READ
@@ skipping 343 matching lines @@
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   GLenum error =  texture_manager()->SetParameter(info, pname, param);
-  if(error != GL_NO_ERROR) {
+  if (error != GL_NO_ERROR) {
     SetGLErrorInvalidParam(error, "glTexParameteri", pname, param);
     return;
   }
   // Texture tracking pools exist only for the command decoder, so
   // do not pass them on to the native GL implementation.
   if (pname == GL_TEXTURE_POOL_CHROMIUM) {
     return;
   }
   glTexParameteri(target, pname, param);
 }
@@ skipping 1086 matching lines @@
 
   if (!CheckBoundFramebuffersValid(function_name)) {
     return error::kNoError;
   }
 
   if (count == 0 || (instanced && primcount == 0)) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
-  if (!state_.vertex_attrib_manager->element_array_buffer(
-      )->GetMaxValueForRange(offset, count, type, &max_vertex_accessed)) {
+  if (!state_.vertex_attrib_manager->element_array_buffer()->
+      GetMaxValueForRange(offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(function_name, max_vertex_accessed, primcount)) {
     if (!ClearUnclearedTextures()) {
       SetGLError(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
     }
@@ skipping 3905 matching lines @@
 
   // Guarantee async textures are always 'cleared' as follows:
   // - AsyncTexImage2D can not redefine an existing texture
   // - AsyncTexImage2D must initialize the entire image via non-null buffer.
   // - AsyncTexSubImage2D clears synchronously if not already cleared.
   // - Textures become immutable after an async call.
   // This way we know in all cases that an async texture is always clear.
   if (!info->SafeToRenderFrom()) {
     if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
       SetGLError(GL_OUT_OF_MEMORY,
-          "glAsyncTexSubImage2DCHROMIUM","dimensions too big");
+          "glAsyncTexSubImage2DCHROMIUM", "dimensions too big");
       return error::kNoError;
     }
   }
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.data_shm_offset;
@@ skipping 17 matching lines @@
   return error::kNoError;
 }
 
 // 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