Clean up interfaces between Shader / ShaderTranslator / ANGLE side.

gpu/command_buffer/service/shader_translator.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/shader_translator.h"
 
 #include <string.h>
 #include <GLES2/gl2.h>
 #include <algorithm>
 
@@ skipping 18 matching lines @@
     TRACE_EVENT0("gpu", "ShFinalize");
     ShFinalize();
   }
 };
 
 base::LazyInstance<ShaderTranslatorInitializer> g_translator_initializer =
     LAZY_INSTANCE_INITIALIZER;
 
 void GetVariableInfo(ShHandle compiler, ShShaderInfo var_type,
                      ShaderTranslator::VariableMap* var_map) {
+  if (!var_map)
+    return;
+  var_map->clear();
+
   size_t name_len = 0, mapped_name_len = 0;
   switch (var_type) {
     case SH_ACTIVE_ATTRIBUTES:
       ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &name_len);
       break;
     case SH_ACTIVE_UNIFORMS:
       ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &name_len);
       break;
     case SH_VARYINGS:
       ShGetInfo(compiler, SH_VARYING_MAX_LENGTH, &name_len);
@@ skipping 26 matching lines @@
     mapped_name.get()[mapped_name_len - 1] = '\0';
 
     ShaderTranslator::VariableInfo info(
         type, size, precision, static_use, name_string);
     (*var_map)[mapped_name.get()] = info;
   }
 }
 
 void GetNameHashingInfo(
     ShHandle compiler, ShaderTranslator::NameMap* name_map) {
+  if (!name_map)
+    return;
+  name_map->clear();
+
   size_t hashed_names_count = 0;
   ShGetInfo(compiler, SH_HASHED_NAMES_COUNT, &hashed_names_count);
   if (hashed_names_count == 0)
     return;
 
   size_t name_max_len = 0, hashed_name_max_len = 0;
   ShGetInfo(compiler, SH_NAME_MAX_LENGTH, &name_max_len);
   ShGetInfo(compiler, SH_HASHED_NAME_MAX_LENGTH, &hashed_name_max_len);
 
   scoped_ptr<char[]> name(new char[name_max_len]);
@@ skipping 54 matching lines @@
   int compile_options =
       SH_OBJECT_CODE | SH_VARIABLES | SH_ENFORCE_PACKING_RESTRICTIONS |
       SH_LIMIT_EXPRESSION_COMPLEXITY | SH_LIMIT_CALL_STACK_DEPTH |
       SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
 
   compile_options |= driver_bug_workarounds_;
 
   return compile_options;
 }
 
-bool ShaderTranslator::Translate(const char* shader) {
+bool ShaderTranslator::Translate(const std::string& shader_source,
+                                 std::string* info_log,
+                                 std::string* translated_source,
+                                 VariableMap* attrib_map,
+                                 VariableMap* uniform_map,
+                                 VariableMap* varying_map,
+                                 NameMap* name_map) const {
   // Make sure this instance is initialized.
   DCHECK(compiler_ != NULL);
-  DCHECK(shader != NULL);
-  ClearResults();
 
   bool success = false;
   {
     TRACE_EVENT0("gpu", "ShCompile");
-    success = !!ShCompile(compiler_, &shader, 1, GetCompileOptions());
+    const char* const shader_strings[] = { shader_source.c_str() };
+    success = !!ShCompile(
+        compiler_, shader_strings, 1, GetCompileOptions());
   }
   if (success) {
-    // Get translated shader.
-    size_t obj_code_len = 0;
-    ShGetInfo(compiler_, SH_OBJECT_CODE_LENGTH, &obj_code_len);
-    if (obj_code_len > 1) {
-      translated_shader_.reset(new char[obj_code_len]);
-      ShGetObjectCode(compiler_, translated_shader_.get());
+    if (translated_source) {
+      translated_source->clear();
+      // Get translated shader.
+      size_t obj_code_len = 0;
+      ShGetInfo(compiler_, SH_OBJECT_CODE_LENGTH, &obj_code_len);
+      if (obj_code_len > 1) {
+        scoped_ptr<char[]> buffer(new char[obj_code_len]);
+        ShGetObjectCode(compiler_, buffer.get());
+        *translated_source = std::string(buffer.get(), obj_code_len - 1);
+      }
     }
-    // Get info for attribs and uniforms.
-    GetVariableInfo(compiler_, SH_ACTIVE_ATTRIBUTES, &attrib_map_);
-    GetVariableInfo(compiler_, SH_ACTIVE_UNIFORMS, &uniform_map_);
-    GetVariableInfo(compiler_, SH_VARYINGS, &varying_map_);
+    // Get info for attribs, uniforms, and varyings.
+    GetVariableInfo(compiler_, SH_ACTIVE_ATTRIBUTES, attrib_map);
+    GetVariableInfo(compiler_, SH_ACTIVE_UNIFORMS, uniform_map);
+    GetVariableInfo(compiler_, SH_VARYINGS, varying_map);
     // Get info for name hashing.
-    GetNameHashingInfo(compiler_, &name_map_);
+    GetNameHashingInfo(compiler_, name_map);
   }
 
   // Get info log.
-  size_t info_log_len = 0;
-  ShGetInfo(compiler_, SH_INFO_LOG_LENGTH, &info_log_len);
-  if (info_log_len > 1) {
-    info_log_.reset(new char[info_log_len]);
-    ShGetInfoLog(compiler_, info_log_.get());
-  } else {
-    info_log_.reset();
+  if (info_log) {
+    info_log->clear();
+    size_t info_log_len = 0;
+    ShGetInfo(compiler_, SH_INFO_LOG_LENGTH, &info_log_len);
+    if (info_log_len > 1) {
+      scoped_ptr<char[]> buffer(new char[info_log_len]);
+      ShGetInfoLog(compiler_, buffer.get());
+      *info_log = std::string(buffer.get(), info_log_len - 1);
+    }
   }
 
   return success;
 }
 
 std::string ShaderTranslator::GetStringForOptionsThatWouldAffectCompilation()
     const {
   DCHECK(compiler_ != NULL);
 
   size_t resource_len = 0;
   ShGetInfo(compiler_, SH_RESOURCES_STRING_LENGTH, &resource_len);
   DCHECK(resource_len > 1);
   scoped_ptr<char[]> resource_str(new char[resource_len]);
 
   ShGetBuiltInResourcesString(compiler_, resource_len, resource_str.get());
 
   return std::string(":CompileOptions:" +
          base::IntToString(GetCompileOptions())) +
          std::string(resource_str.get());
 }
 
-const char* ShaderTranslator::translated_shader() const {
-  return translated_shader_.get();
-}
-
-const char* ShaderTranslator::info_log() const {
-  return info_log_.get();
-}
-
-const ShaderTranslatorInterface::VariableMap&
-ShaderTranslator::attrib_map() const {
-  return attrib_map_;
-}
-
-const ShaderTranslatorInterface::VariableMap&
-ShaderTranslator::uniform_map() const {
-  return uniform_map_;
-}
-
-const ShaderTranslatorInterface::VariableMap&
-ShaderTranslator::varying_map() const {
-  return varying_map_;
-}
-
-const ShaderTranslatorInterface::NameMap&
-ShaderTranslator::name_map() const {
-  return name_map_;
-}
-
 void ShaderTranslator::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void ShaderTranslator::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
 ShaderTranslator::~ShaderTranslator() {
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnDestruct(this));
 
   if (compiler_ != NULL)
     ShDestruct(compiler_);
 }
 
-void ShaderTranslator::ClearResults() {
-  translated_shader_.reset();
-  info_log_.reset();
-  attrib_map_.clear();
-  uniform_map_.clear();
-  varying_map_.clear();
-  name_map_.clear();
-}
-
 }  // namespace gles2
 }  // namespace gpu