Clean up interfaces between Shader / ShaderTranslator / ANGLE side.

gpu/command_buffer/service/program_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/service/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 503 matching lines @@
 
 void Program::ExecuteBindAttribLocationCalls() {
   for (LocationMap::const_iterator it = bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (mapped_name && *mapped_name != it->first)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
   }
 }
 
-void ProgramManager::DoCompileShader(
-    Shader* shader,
-    ShaderTranslator* translator,
-    ProgramManager::TranslatedShaderSourceType translated_shader_source_type) {
-  // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
-  // glShaderSource and then glCompileShader.
-  const std::string* source = shader->source();
-  const char* shader_src = source ? source->c_str() : "";
-  if (translator) {
-    if (!translator->Translate(shader_src)) {
-      shader->SetStatus(false, translator->info_log(), NULL);
-      return;
-    }
-    shader_src = translator->translated_shader();
-    if (translated_shader_source_type != kANGLE)
-      shader->UpdateTranslatedSource(shader_src);
-  }
-
-  glShaderSource(shader->service_id(), 1, &shader_src, NULL);
-  glCompileShader(shader->service_id());
-  if (translated_shader_source_type == kANGLE) {
-    GLint max_len = 0;
-    glGetShaderiv(shader->service_id(),
-                  GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE,
-                  &max_len);
-    scoped_ptr<char[]> temp(new char[max_len]);
-    GLint len = 0;
-    glGetTranslatedShaderSourceANGLE(
-        shader->service_id(), max_len, &len, temp.get());
-    DCHECK(max_len == 0 || len < max_len);
-    DCHECK(len == 0 || temp[len] == '\0');
-    shader->UpdateTranslatedSource(max_len ? temp.get() : NULL);
-  }
-
-  GLint status = GL_FALSE;
-  glGetShaderiv(shader->service_id(), GL_COMPILE_STATUS, &status);
-  if (status) {
-    shader->SetStatus(true, "", translator);
-  } else {
-    // We cannot reach here if we are using the shader translator.
-    // All invalid shaders must be rejected by the translator.
-    // All translated shaders must compile.
-    GLint max_len = 0;
-    glGetShaderiv(shader->service_id(), GL_INFO_LOG_LENGTH, &max_len);
-    scoped_ptr<char[]> temp(new char[max_len]);
-    GLint len = 0;
-    glGetShaderInfoLog(shader->service_id(), max_len, &len, temp.get());
-    DCHECK(max_len == 0 || len < max_len);
-    DCHECK(len == 0 || temp[len] == '\0');
-    shader->SetStatus(false, std::string(temp.get(), len).c_str(), NULL);
-    LOG_IF(ERROR, translator)
-        << "Shader translator allowed/produced an invalid shader "
-        << "unless the driver is buggy:"
-        << "\n--original-shader--\n" << (source ? *source : std::string())
-        << "\n--translated-shader--\n" << shader_src << "\n--info-log--\n"
-        << *shader->log_info();
-  }
-}
-
 bool Program::Link(ShaderManager* manager,
                    ShaderTranslator* vertex_translator,
                    ShaderTranslator* fragment_translator,
                    Program::VaryingsPackingOption varyings_packing_option,
                    const ShaderCacheCallback& shader_callback) {
   ClearLinkStatus();
   if (!CanLink()) {
     set_log_info("missing shaders");
     return false;
   }
@@ skipping 23 matching lines @@
   }
   if (!CheckVaryingsPacking(varyings_packing_option)) {
     set_log_info("Varyings over maximum register limit");
     return false;
   }
 
   TimeTicks before_time = TimeTicks::HighResNow();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
-    DCHECK(attached_shaders_[0]->signature_source() &&
-           attached_shaders_[1]->signature_source());
+    DCHECK(!attached_shaders_[0]->signature_source().empty() &&
+           !attached_shaders_[1]->signature_source().empty());
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
-        *attached_shaders_[0]->signature_source(),
+        attached_shaders_[0]->signature_source(),
         vertex_translator,
-        *attached_shaders_[1]->signature_source(),
+        attached_shaders_[1]->signature_source(),
         fragment_translator,
         &bind_attrib_location_map_);
 
     if (status == ProgramCache::LINK_SUCCEEDED) {
       ProgramCache::ProgramLoadResult success =
           cache->LoadLinkedProgram(service_id(),
                                    attached_shaders_[0].get(),
                                    vertex_translator,
                                    attached_shaders_[1].get(),
                                    fragment_translator,
@@ skipping 392 matching lines @@
   DCHECK(shader_manager);
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
     if (attached_shaders_[ii].get()) {
       DetachShader(shader_manager, attached_shaders_[ii].get());
     }
   }
 }
 
 bool Program::CanLink() const {
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
-    if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->IsValid()) {
+    if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->valid()) {
       return false;
     }
   }
   return true;
 }
 
 bool Program::DetectAttribLocationBindingConflicts() const {
   std::set<GLint> location_binding_used;
   for (LocationMap::const_iterator it = bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     // Find out if an attribute is declared in this program's shaders.
     bool active = false;
     for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
-      if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->IsValid())
+      if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->valid())
         continue;
       if (attached_shaders_[ii]->GetAttribInfo(it->first)) {
         active = true;
         break;
       }
     }
     if (active) {
       std::pair<std::set<GLint>::iterator, bool> result =
           location_binding_used.insert(it->second);
       if (!result.second)
@@ skipping 355 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu