Adds

  glGetActiveAttrib
  glGetActiveUniform
  glGetAttachedShaders
  glGetShaderPrecision




TEST=none
BUG=none

Review URL: http://codereview.chromium.org/577017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@38270 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 251 insertions, 45 deletions

diff --git a/gpu/command_buffer/client/cmd_buffer_helper.h b/gpu/command_buffer/client/cmd_buffer_helper.h
index 72984d1..c65a23a 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper.h
+++ b/gpu/command_buffer/client/cmd_buffer_helper.h
@@ -117,6 +117,78 @@ class CommandBufferHelper {
     cmd.Init(token);
   }
 
+  void Jump(uint32 offset) {
+    cmd::Jump& cmd = GetCmdSpace<cmd::Jump>();
+    cmd.Init(offset);
+  }
+
+  void JumpRelative(int32 offset) {
+    cmd::JumpRelative& cmd = GetCmdSpace<cmd::JumpRelative>();
+    cmd.Init(offset);
+  }
+
+  void Call(uint32 offset) {
+    cmd::Call& cmd = GetCmdSpace<cmd::Call>();
+    cmd.Init(offset);
+  }
+
+  void CallRelative(int32 offset) {
+    cmd::CallRelative& cmd = GetCmdSpace<cmd::CallRelative>();
+    cmd.Init(offset);
+  }
+
+  void Return() {
+    cmd::Return& cmd = GetCmdSpace<cmd::Return>();
+    cmd.Init();
+  }
+
+  void SetBucketSize(uint32 bucket_id, uint32 size) {
+    cmd::SetBucketSize& cmd = GetCmdSpace<cmd::SetBucketSize>();
+    cmd.Init(bucket_id, size);
+  }
+
+  void SetBucketData(uint32 bucket_id,
+                     uint32 offset,
+                     uint32 size,
+                     uint32 shared_memory_id,
+                     uint32 shared_memory_offset) {
+    cmd::SetBucketData& cmd = GetCmdSpace<cmd::SetBucketData>();
+    cmd.Init(bucket_id,
+             offset,
+             size,
+             shared_memory_id,
+             shared_memory_offset);
+  }
+
+  void SetBucketDataImmediate(
+      uint32 bucket_id, uint32 offset, const void* data, uint32 size) {
+    cmd::SetBucketDataImmediate& cmd =
+        GetImmediateCmdSpace<cmd::SetBucketDataImmediate>(size);
+    cmd.Init(bucket_id, offset, size);
+    memcpy(ImmediateDataAddress(&cmd), data, size);
+  }
+
+  void GetBucketSize(uint32 bucket_id,
+                     uint32 shared_memory_id,
+                     uint32 shared_memory_offset) {
+    cmd::GetBucketSize& cmd = GetCmdSpace<cmd::GetBucketSize>();
+    cmd.Init(bucket_id,
+             shared_memory_id,
+             shared_memory_offset);
+  }
+
+  void GetBucketData(uint32 bucket_id,
+                     uint32 offset,
+                     uint32 size,
+                     uint32 shared_memory_id,
+                     uint32 shared_memory_offset) {
+    cmd::GetBucketData& cmd = GetCmdSpace<cmd::GetBucketData>();
+    cmd.Init(bucket_id,
+             offset,
+             size,
+             shared_memory_id,
+             shared_memory_offset);
+  }
 
  private:
   // Waits until get changes, updating the value of get_.
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index 66eea9d..5e63eb8 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -425,37 +425,24 @@
   }
 
   void GetActiveAttrib(
-      GLuint program, GLuint index, GLsizei bufsize, uint32 length_shm_id,
-      uint32 length_shm_offset, uint32 size_shm_id, uint32 size_shm_offset,
-      uint32 type_shm_id, uint32 type_shm_offset, uint32 name_shm_id,
-      uint32 name_shm_offset) {
+      GLuint program, GLuint index, uint32 name_bucket_id, uint32 result_shm_id,
+      uint32 result_shm_offset) {
     gles2::GetActiveAttrib& c = GetCmdSpace<gles2::GetActiveAttrib>();
-    c.Init(
-        program, index, bufsize, length_shm_id, length_shm_offset, size_shm_id,
-        size_shm_offset, type_shm_id, type_shm_offset, name_shm_id,
-        name_shm_offset);
+    c.Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
   }
 
   void GetActiveUniform(
-      GLuint program, GLuint index, GLsizei bufsize, uint32 length_shm_id,
-      uint32 length_shm_offset, uint32 size_shm_id, uint32 size_shm_offset,
-      uint32 type_shm_id, uint32 type_shm_offset, uint32 name_shm_id,
-      uint32 name_shm_offset) {
+      GLuint program, GLuint index, uint32 name_bucket_id, uint32 result_shm_id,
+      uint32 result_shm_offset) {
     gles2::GetActiveUniform& c = GetCmdSpace<gles2::GetActiveUniform>();
-    c.Init(
-        program, index, bufsize, length_shm_id, length_shm_offset, size_shm_id,
-        size_shm_offset, type_shm_id, type_shm_offset, name_shm_id,
-        name_shm_offset);
+    c.Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
   }
 
   void GetAttachedShaders(
-      GLuint program, GLsizei maxcount, uint32 count_shm_id,
-      uint32 count_shm_offset, uint32 shaders_shm_id,
-      uint32 shaders_shm_offset) {
+      GLuint program, uint32 result_shm_id, uint32 result_shm_offset,
+      uint32 result_size) {
     gles2::GetAttachedShaders& c = GetCmdSpace<gles2::GetAttachedShaders>();
-    c.Init(
-        program, maxcount, count_shm_id, count_shm_offset, shaders_shm_id,
-        shaders_shm_offset);
+    c.Init(program, result_shm_id, result_shm_offset, result_size);
   }
 
   void GetBooleanv(
@@ -540,14 +527,11 @@
   }
 
   void GetShaderPrecisionFormat(
-      GLenum shadertype, GLenum precisiontype, uint32 range_shm_id,
-      uint32 range_shm_offset, uint32 precision_shm_id,
-      uint32 precision_shm_offset) {
+      GLenum shadertype, GLenum precisiontype, uint32 result_shm_id,
+      uint32 result_shm_offset) {
     gles2::GetShaderPrecisionFormat& c =
         GetCmdSpace<gles2::GetShaderPrecisionFormat>();
-    c.Init(
-        shadertype, precisiontype, range_shm_id, range_shm_offset,
-        precision_shm_id, precision_shm_offset);
+    c.Init(shadertype, precisiontype, result_shm_id, result_shm_offset);
   }
 
   void GetShaderSource(
diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index 8ea20ab..edeb1fa 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -54,15 +54,71 @@ void GLES2Implementation::FreeIds(GLsizei n, const GLuint* ids) {
   }
 }
 
-void GLES2Implementation::CopyResult(void* dst) {
-  SizedResult* result = static_cast<SizedResult*>(result_buffer_);
-  memcpy(dst, result->GetDataAs<void*>(), result->size);
-}
-
 void GLES2Implementation::WaitForCmd() {
   helper_->CommandBufferHelper::Finish();
 }
 
+void GLES2Implementation::GetBucketContents(uint32 bucket_id,
+                                            std::vector<int8>* data) {
+  DCHECK(data);
+  helper_->GetBucketSize(bucket_id, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  uint32 size = GetResultAs<cmd::GetBucketSize::Result>();
+  data->resize(size);
+  if (size > 0u) {
+    uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+    uint32 offset = 0;
+    while (size) {
+      uint32 part_size = std::min(max_size, size);
+      void* buffer = transfer_buffer_.Alloc(part_size);
+      helper_->GetBucketData(
+          bucket_id, offset, part_size,
+          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+      WaitForCmd();
+      memcpy(&(*data)[offset], buffer, part_size);
+      transfer_buffer_.Free(buffer);
+      offset += part_size;
+      size -= part_size;
+    }
+    // Free the bucket. This is not required but it does free up the memory.
+    // and we don't have to wait for the result so from the client's perspective
+    // it's cheap.
+    helper_->SetBucketSize(bucket_id, 0);
+  }
+}
+
+void GLES2Implementation::SetBucketContents(
+    uint32 bucket_id, const void* data, size_t size) {
+  DCHECK(data);
+  helper_->SetBucketSize(bucket_id, size);
+  if (size > 0u) {
+    uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+    uint32 offset = 0;
+    while (size) {
+      uint32 part_size = std::min(static_cast<size_t>(max_size), size);
+      void* buffer = transfer_buffer_.Alloc(part_size);
+      memcpy(buffer, static_cast<const int8*>(data) + offset, part_size);
+      helper_->SetBucketData(
+          bucket_id, offset, part_size,
+          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+      offset += part_size;
+      size -= part_size;
+    }
+  }
+}
+
+std::string GLES2Implementation::GetBucketAsString(uint32 bucket_id) {
+  std::vector<int8> data;
+  GetBucketContents(bucket_id, &data);
+  return std::string(reinterpret_cast<char*>(&data[0]), data.size());
+}
+
+void GLES2Implementation::SetBucketAsString(
+    uint32 bucket_id, const std::string& str) {
+  SetBucketContents(bucket_id, str.c_str(), str.size());
+}
+
 void GLES2Implementation::DrawElements(
     GLenum mode, GLsizei count, GLenum type, const void* indices) {
   helper_->DrawElements(mode, count, type, ToGLuint(indices));
@@ -79,7 +135,7 @@ void GLES2Implementation::Flush() {
 void GLES2Implementation::Finish() {
   // Insert the cmd to call glFinish
   helper_->Finish();
-  // Flinish our command buffer
+  // Finish our command buffer
   // (tell the service to execute upto the Finish cmd and wait for it to
   // execute.)
   helper_->CommandBufferHelper::Finish();
@@ -95,7 +151,8 @@ void GLES2Implementation::GetVertexAttribPointerv(
   helper_->GetVertexAttribPointerv(
     index, pname, result_shm_id(), result_shm_offset());
   WaitForCmd();
-  CopyResult(ptr);
+  static_cast<gles2::GetVertexAttribPointerv::Result*>(
+      result_buffer_)->CopyResult(ptr);
 };
 
 GLint GLES2Implementation::GetAttribLocation(
@@ -299,18 +356,82 @@ GLenum GLES2Implementation::CheckFramebufferStatus(GLenum target) {
 void GLES2Implementation::GetActiveAttrib(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
-  // TODO(gman): implement.
+  typedef gles2::GetActiveAttrib::Result Result;
+  Result* result = static_cast<Result*>(result_buffer_);
+  helper_->GetActiveAttrib(program, index, kResultBucketId,
+                           result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  if (result->success) {
+    if (size) {
+      *size = result->size;
+    }
+    if (type) {
+      *type = result->type;
+    }
+    if (length || name) {
+      std::vector<int8> str;
+      GetBucketContents(kResultBucketId, &str);
+      GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
+                                  str.size());
+      if (length) {
+        *length = max_size;
+      }
+      if (name && bufsize > 0) {
+        memcpy(name, &str[0], max_size);
+        name[max_size] = '\0';
+      }
+    }
+  }
 }
 
 void GLES2Implementation::GetActiveUniform(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
-  // TODO(gman): implement.
+  typedef gles2::GetActiveUniform::Result Result;
+  Result* result = static_cast<Result*>(result_buffer_);
+  helper_->GetActiveUniform(program, index, kResultBucketId,
+                            result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  if (result->success) {
+    if (size) {
+      *size = result->size;
+    }
+    if (type) {
+      *type = result->type;
+    }
+    if (length || name) {
+      std::vector<int8> str;
+      GetBucketContents(kResultBucketId, &str);
+      GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
+                                  str.size());
+      if (length) {
+        *length = max_size;
+      }
+      if (name && bufsize > 0) {
+        memcpy(name, &str[0], max_size);
+        name[max_size] = '\0';
+      }
+    }
+  }
 }
 
 void GLES2Implementation::GetAttachedShaders(
     GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
-  // TODO(gman): implement.
+  typedef gles2::GetAttachedShaders::Result Result;
+  uint32 size = Result::ComputeSize(maxcount);
+  Result* result = transfer_buffer_.AllocTyped<Result>(size);
+  helper_->GetAttachedShaders(
+    program,
+    transfer_buffer_id_,
+    transfer_buffer_.GetOffset(result),
+    size);
+  int32 token = helper_->InsertToken();
+  WaitForCmd();
+  if (count) {
+    *count = result->GetNumResults();
+  }
+  result->CopyResult(shaders);
+  transfer_buffer_.FreePendingToken(result, token);
 }
 
 void GLES2Implementation::GetProgramInfoLog(
@@ -325,7 +446,20 @@ void GLES2Implementation::GetShaderInfoLog(
 
 void GLES2Implementation::GetShaderPrecisionFormat(
     GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
-  // TODO(gman): implement.
+  typedef gles2::GetShaderPrecisionFormat::Result Result;
+  Result* result = static_cast<Result*>(result_buffer_);
+  helper_->GetShaderPrecisionFormat(
+    shadertype, precisiontype, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  if (result->success) {
+    if (range) {
+      range[0] = result->min_range;
+      range[1] = result->max_range;
+    }
+    if (precision) {
+      precision[0] = result->precision;
+    }
+  }
 }
 
 void GLES2Implementation::GetShaderSource(
@@ -343,7 +477,7 @@ void GLES2Implementation::GetUniformfv(
   helper_->GetUniformfv(
       program, location, result_shm_id(), result_shm_offset());
   WaitForCmd();
-  CopyResult(params);
+  static_cast<gles2::GetUniformfv::Result*>(result_buffer_)->CopyResult(params);
 }
 
 void GLES2Implementation::GetUniformiv(
@@ -351,7 +485,7 @@ void GLES2Implementation::GetUniformiv(
   helper_->GetUniformiv(
       program, location, result_shm_id(), result_shm_offset());
   WaitForCmd();
-  CopyResult(params);
+  static_cast<gles2::GetUniformfv::Result*>(result_buffer_)->CopyResult(params);
 }
 
 void GLES2Implementation::ReadPixels(
diff --git a/gpu/command_buffer/client/gles2_implementation.h b/gpu/command_buffer/client/gles2_implementation.h
index ac519f9..579e0d3 100644
--- a/gpu/command_buffer/client/gles2_implementation.h
+++ b/gpu/command_buffer/client/gles2_implementation.h
@@ -5,6 +5,8 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
+#include <string>
+#include <vector>
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/id_allocator.h"
@@ -63,14 +65,28 @@ class GLES2Implementation {
     return *static_cast<T*>(result_buffer_);
   }
 
-  // Copies the result.
-  void CopyResult(void* dst);
-
   // Waits for all commands to execute.
   void WaitForCmd();
 
+  // TODO(gman): These bucket functions really seem like they belong in
+  // CommandBufferHelper (or maybe BucketHelper?). Unfortunately they need
+  // a transfer buffer to function which is currently managed by this class.
+
+  // Gets the contents of a bucket.
+  void GetBucketContents(uint32 bucket_id, std::vector<int8>* data);
+
+  // Sets the contents of a bucket.
+  void SetBucketContents(uint32 bucket_id, const void* data, size_t size);
+
+  // Gets the contents of a bucket as a string.
+  std::string GetBucketAsString(uint32 bucket_id);
+
+  // Sets the contents of a bucket as a string.
+  void SetBucketAsString(uint32 bucket_id, const std::string& str);
+
   // The maxiumum result size from simple GL get commands.
-  static const size_t kMaxSizeOfSimpleResult = 4 * sizeof(uint32);  // NOLINT.
+  static const size_t kMaxSizeOfSimpleResult = 16 * sizeof(uint32);  // NOLINT.
+  static const uint32 kResultBucketId = 1;
 
   GLES2Util util_;
   GLES2CmdHelper* helper_;