Add UniformBlocks related commands to command buffer.

gpu/command_buffer/client/program_info_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/client/program_info_manager.h"
 
-#include "base/numerics/safe_math.h"
-
 namespace {
 
 template<typename T> static T LocalGetAs(
     const std::vector<int8>& data, uint32 offset, size_t size) {
   const int8* p = &data[0] + offset;
   if (offset + size > data.size()) {
     NOTREACHED();
     return NULL;
   }
   return static_cast<T>(static_cast<const void*>(p));
@@ skipping 223 matching lines @@
   if (cached_es3_uniform_blocks_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   uniform_blocks_.clear();
   active_uniform_block_max_name_length_ = 0;
 
+  // |result| comes from GPU process. We consider it trusted data. Therefore,
+  // no need to check for overflows as the GPU side did the checks already.
   uint32_t header_size = sizeof(UniformBlocksHeader);
   DCHECK_GE(result.size(), header_size);
   const UniformBlocksHeader* header = LocalGetAs<const UniformBlocksHeader*>(
       result, 0, header_size);
   DCHECK(header);
   if (header->num_uniform_blocks == 0) {
     DCHECK_EQ(result.size(), header_size);
     // TODO(zmo): Here we can't tell if no uniform blocks are defined, or
     // the previous link failed.
     return;
@@ skipping 267 matching lines @@
 
 GLuint ProgramInfoManager::GetUniformBlockIndex(
     GLES2Implementation* gl, GLuint program, const char* name) {
   {
     base::AutoLock auto_lock(lock_);
     Program* info = GetProgramInfo(gl, program, kES3UniformBlocks);
     if (info) {
       return info->GetUniformBlockIndex(name);
     }
   }
-  return false;
-  // TODO(zmo): return gl->GetUniformBlockIndexHelper(program, name);
+  return gl->GetUniformBlockIndexHelper(program, name);
 }
 
 bool ProgramInfoManager::GetActiveUniformBlockName(
     GLES2Implementation* gl, GLuint program, GLuint index,
     GLsizei buf_size, GLsizei* length, char* name) {
+  DCHECK_LE(0, buf_size);
+  if (!name) {
+    buf_size = 0;
+  }
   {
     base::AutoLock auto_lock(lock_);
     Program* info = GetProgramInfo(gl, program, kES3UniformBlocks);
     if (info) {
       const Program::UniformBlock* uniform_block = info->GetUniformBlock(index);
-      if (uniform_block && buf_size >= 1) {
-        GLsizei written_size = std::min(
-            buf_size, static_cast<GLsizei>(uniform_block->name.size()) + 1);
-        if (length) {
-          *length = written_size - 1;
+      if (uniform_block) {
+        if (buf_size == 0) {
+          if (length) {
+            *length = 0;
+          }
+        } else if (length || name) {
+          GLsizei max_size = std::min(
+              buf_size - 1, static_cast<GLsizei>(uniform_block->name.size()));
+          if (length) {
+            *length = max_size;
+          }
+          if (name) {
+            memcpy(name, uniform_block->name.data(), max_size);
+            name[max_size] = '\0';
+          }
         }
-        memcpy(name, uniform_block->name.c_str(), written_size);
         return true;
       }
     }
   }
-  return false;
-  // TODO(zmo): return gl->GetActiveUniformBlockNameHelper(
-  //                program, index, buf_size, length, name);
+  return gl->GetActiveUniformBlockNameHelper(
+      program, index, buf_size, length, name);
 }
 
 bool ProgramInfoManager::GetActiveUniformBlockiv(
     GLES2Implementation* gl, GLuint program, GLuint index,
     GLenum pname, GLint* params) {
   {
     base::AutoLock auto_lock(lock_);
     Program* info = GetProgramInfo(gl, program, kES3UniformBlocks);
     if (info) {
       const Program::UniformBlock* uniform_block = info->GetUniformBlock(index);
@@ skipping 50 matching lines @@
     }
   }
   return false;
   // TODO(zmo): return gl->GetActiveUniformBlockivHelper(
   //                program, index, pname, params);
 }
 
 }  // namespace gles2
 }  // namespace gpu