Clean up interfaces between Shader / ShaderTranslator / ANGLE side.

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 6816 matching lines @@
 // memory.)
 error::Error GLES2DecoderImpl::ShaderSourceHelper(
     GLuint client_id, const char* data, uint32 data_size) {
   std::string str(data, data + data_size);
   Shader* shader = GetShaderInfoNotProgram(client_id, "glShaderSource");
   if (!shader) {
     return error::kNoError;
   }
   // Note: We don't actually call glShaderSource here. We wait until
   // the call to glCompileShader.
-  shader->UpdateSource(str.c_str());
+  shader->set_source(str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSourceBucket(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::ShaderSourceBucket& c =
       *static_cast<const gles2::cmds::ShaderSourceBucket*>(cmd_data);
   Bucket* bucket = GetBucket(c.data_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   return ShaderSourceHelper(
       c.shader, bucket->GetDataAs<const char*>(0, bucket->size() - 1),
       bucket->size() - 1);
 }
 
 void GLES2DecoderImpl::DoCompileShader(GLuint client_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCompileShader");
   Shader* shader = GetShaderInfoNotProgram(client_id, "glCompileShader");
   if (!shader) {
     return;
   }
   ShaderTranslator* translator = NULL;
   if (use_shader_translator_) {
     translator = shader->shader_type() == GL_VERTEX_SHADER ?
         vertex_translator_.get() : fragment_translator_.get();
   }
 
-  program_manager()->DoCompileShader(
-     shader,
+  shader->DoCompile(
      translator,
      feature_info_->feature_flags().angle_translated_shader_source ?
-         ProgramManager::kANGLE : ProgramManager::kGL);
+         Shader::kANGLE : Shader::kGL);
 
   // CompileShader can be very slow.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader_id, GLenum pname, GLint* params) {
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderiv");
   if (!shader) {
     return;
   }
   switch (pname) {
     case GL_SHADER_SOURCE_LENGTH:
-      *params = shader->source() ? shader->source()->size() + 1 : 0;
+      *params = shader->source().size();
+      if (*params)
+        ++(*params);
       return;
     case GL_COMPILE_STATUS:
-      *params = compile_shader_always_succeeds_ ? true : shader->IsValid();
+      *params = compile_shader_always_succeeds_ ? true : shader->valid();
       return;
     case GL_INFO_LOG_LENGTH:
-      *params = shader->log_info() ? shader->log_info()->size() + 1 : 0;
+      *params = shader->log_info().size();
+      if (*params)
+        ++(*params);
       return;
     case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
-      *params = shader->translated_source() ?
-          shader->translated_source()->size() + 1 : 0;
+      *params = shader->translated_source().size();
+      if (*params)
+        ++(*params);
       return;
     default:
       break;
   }
   glGetShaderiv(shader->service_id(), pname, params);
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderSource(uint32 immediate_data_size,
                                                      const void* cmd_data) {
   const gles2::cmds::GetShaderSource& c =
       *static_cast<const gles2::cmds::GetShaderSource*>(cmd_data);
   GLuint shader_id = c.shader;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderSource");
-  if (!shader || !shader->source()) {
+  if (!shader || shader->source().empty()) {
     bucket->SetSize(0);
     return error::kNoError;
   }
-  bucket->SetFromString(shader->source()->c_str());
+  bucket->SetFromString(shader->source().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTranslatedShaderSourceANGLE(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetTranslatedShaderSourceANGLE& c =
       *static_cast<const gles2::cmds::GetTranslatedShaderSourceANGLE*>(
           cmd_data);
   GLuint shader_id = c.shader;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(
       shader_id, "glGetTranslatedShaderSourceANGLE");
   if (!shader) {
     bucket->SetSize(0);
     return error::kNoError;
   }
 
-  bucket->SetFromString(shader->translated_source() ?
-      shader->translated_source()->c_str() : NULL);
+  bucket->SetFromString(shader->translated_source().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetProgramInfoLog& c =
       *static_cast<const gles2::cmds::GetProgramInfoLog*>(cmd_data);
   GLuint program_id = c.program;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
@@ skipping 10 matching lines @@
 
 error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetShaderInfoLog& c =
       *static_cast<const gles2::cmds::GetShaderInfoLog*>(cmd_data);
   GLuint shader_id = c.shader;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderInfoLog");
-  if (!shader || !shader->log_info()) {
+  if (!shader) {
     bucket->SetFromString("");
     return error::kNoError;
   }
-  bucket->SetFromString(shader->log_info()->c_str());
+  bucket->SetFromString(shader->log_info().c_str());
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
   return state_.GetEnabled(cap);
 }
 
 bool GLES2DecoderImpl::DoIsBuffer(GLuint client_id) {
   const Buffer* buffer = GetBuffer(client_id);
   return buffer && buffer->IsValid() && !buffer->IsDeleted();
@@ skipping 4255 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