command_buffer: Implement EXT_blend_func_extended

gpu/command_buffer/service/shader_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/shader_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 51 matching lines @@
   // Signify the shader has been compiled, whether or not it is valid
   // is dependent on the |valid_| member variable.
   shader_state_ = kShaderStateCompiled;
   valid_ = false;
 
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
   const char* source_for_driver = last_compiled_source_.c_str();
   ShaderTranslatorInterface* translator = translator_.get();
   if (translator) {
-    bool success = translator->Translate(last_compiled_source_,
-                                         &log_info_,
-                                         &translated_source_,
-                                         &shader_version_,
-                                         &attrib_map_,
-                                         &uniform_map_,
-                                         &varying_map_,
-                                         &name_map_);
+    bool success = translator->Translate(
+        last_compiled_source_, &log_info_, &translated_source_,
+        &shader_version_, &attrib_map_, &uniform_map_, &varying_map_,
+        &output_variable_list_, &name_map_);
     if (!success) {
       return;
     }
     source_for_driver = translated_source_.c_str();
   }
 
   glShaderSource(service_id_, 1, &source_for_driver, NULL);
   glCompileShader(service_id_);
   if (source_type_ == kANGLE) {
     GLint max_len = 0;
@@ skipping 104 matching lines @@
 const sh::Uniform* Shader::GetUniformInfo(const std::string& name) const {
   UniformMap::const_iterator it = uniform_map_.find(GetTopVariableName(name));
   return it != uniform_map_.end() ? &it->second : NULL;
 }
 
 const sh::Varying* Shader::GetVaryingInfo(const std::string& name) const {
   VaryingMap::const_iterator it = varying_map_.find(GetTopVariableName(name));
   return it != varying_map_.end() ? &it->second : NULL;
 }
 
+const sh::Attribute* Shader::GetOutputVariableInfo(
+    const std::string& original_name) const {
+  auto iter =
+      std::find_if(output_variable_list_.begin(), output_variable_list_.end(),
+                   [original_name](const sh::Attribute& output_var) {
+                     return output_var.mappedName == original_name;

[Zhenyao Mo, 2015/08/31 21:12:31]

This looks incorrect.  It should be output_var.originalName == original_name.

Also, at least add a TODO that if this lookup ever becomes perf concern,
implement a hash_map for the data.

[Kimmo Kinnunen, 2015/09/24 13:16:28]

Done.
The idea is to use list rather than map, since there is ever only few output
variables.
I added an comment. We can use a map, if need be.

+                   });
+  return iter != output_variable_list_.end() ? &(*iter) : nullptr;
+}
+
 ShaderManager::ShaderManager() {}
 
 ShaderManager::~ShaderManager() {
   DCHECK(shaders_.empty());
 }
 
 void ShaderManager::Destroy(bool have_context) {
   while (!shaders_.empty()) {
     if (have_context) {
       Shader* shader = shaders_.begin()->second.get();
@@ skipping 72 matching lines @@
 
 void ShaderManager::UnuseShader(Shader* shader) {
   DCHECK(shader);
   DCHECK(IsOwned(shader));
   shader->DecUseCount();
   RemoveShader(shader);
 }
 
 }  // namespace gles2
 }  // namespace gpu