Validate fbo color image format and fragment shader output variable type.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 99 matching lines @@
   if (hit == varyings.end())
     return false;
   return hit->second.isInvariant;
 }
 
 uint32_t ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8_t*>(position) -
          static_cast<const uint8_t*>(start);
 }
 
+ShaderVariableBaseType FragmentOutputTypeToBaseType(GLenum type) {
+  switch (type) {
+    case GL_INT:
+    case GL_INT_VEC2:
+    case GL_INT_VEC3:
+    case GL_INT_VEC4:
+      return SHADER_VARIABLE_INT;
+    case GL_UNSIGNED_INT:
+    case GL_UNSIGNED_INT_VEC2:
+    case GL_UNSIGNED_INT_VEC3:
+    case GL_UNSIGNED_INT_VEC4:
+      return SHADER_VARIABLE_UINT;
+    case GL_FLOAT:
+    case GL_FLOAT_VEC2:
+    case GL_FLOAT_VEC3:
+    case GL_FLOAT_VEC4:
+      return SHADER_VARIABLE_FLOAT;
+    default:
+      NOTREACHED();
+      return SHADER_VARIABLE_UNDEFINED_TYPE;
+  }
+}
+
 }  // anonymous namespace.
 
 Program::UniformInfo::UniformInfo()
     : size(0),
       type(GL_NONE),
       accepts_api_type(0),
       fake_location_base(0),
       is_array(false) {}
 
 Program::UniformInfo::UniformInfo(const std::string& client_name,
@@ skipping 135 matching lines @@
     : manager_(manager),
       use_count_(0),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       service_id_(service_id),
       deleted_(false),
       valid_(false),
       link_status_(false),
       uniforms_cleared_(false),
       transform_feedback_buffer_mode_(GL_NONE) {
+  DCHECK(manager_);
+  fragment_output_base_types_.reset(
+      new ShaderVariableBaseType[manager_->max_draw_buffers()]);
+  ResetFragmentOutputBaseTypes();
   manager_->StartTracking(this);
 }
 
 void Program::Reset() {
   valid_ = false;
   link_status_ = false;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
   uniform_infos_.clear();
   uniform_locations_.clear();
   fragment_input_infos_.clear();
   fragment_input_locations_.clear();
   program_output_infos_.clear();
   sampler_indices_.clear();
   attrib_location_to_index_map_.clear();
+  ResetFragmentOutputBaseTypes();
+}
+
+void Program::ResetFragmentOutputBaseTypes() {
+  for (uint32_t ii = 0; ii < manager_->max_draw_buffers(); ++ii) {
+    fragment_output_base_types_[ii] = SHADER_VARIABLE_UNDEFINED_TYPE;
+  }
+}
+
+void Program::UpdateFragmentOutputBaseTypes() {
+  ResetFragmentOutputBaseTypes();
+  Shader* fragment_shader =
+      attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
+  DCHECK(fragment_shader);
+  for (auto const& output : fragment_shader->output_variable_list()) {
+    DCHECK(output.location == -1 ||
+           (output.location >= 0 &&
+            output.location < static_cast<int>(manager_->max_draw_buffers())));
+    if (ProgramManager::HasBuiltInPrefix(output.name)) {
+      if (output.name != "gl_FragColor" && output.name != "gl_FragData")
+        continue;
+    }
+    int draw_buffer = (output.location == -1 ? 0 : output.location);
+    int count = static_cast<int>(output.arraySize == 0 ? 1 : output.arraySize);
+    // TODO(zmo): Handle the special case in ES2 where gl_FragColor could
+    // be broadcasting to all draw buffers.
+    DCHECK_LE(draw_buffer + count,
+              static_cast<int>(manager_->max_draw_buffers()));
+    for (int ii = draw_buffer; ii < draw_buffer + count; ++ii) {
+      DCHECK_EQ(SHADER_VARIABLE_UNDEFINED_TYPE,
+                fragment_output_base_types_[ii]);
+      fragment_output_base_types_[ii] =
+          FragmentOutputTypeToBaseType(output.type);
+    }
+  }
 }
 
 std::string Program::ProcessLogInfo(
     const std::string& log) {
   std::string output;
   re2::StringPiece input(log);
   std::string prior_log;
   std::string hashed_name;
   while (RE2::Consume(&input,
                       "(.*?)(webgl_[0123456789abcdefABCDEF]+)",
@@ skipping 215 matching lines @@
     for (const UniformInfo& info : uniform_infos_) {
       DVLOG(1) << ii++ << ": loc = " << info.element_locations[0]
                << ", size = " << info.size
                << ", type = " << GLES2Util::GetStringEnum(info.type)
                << ", name = " << info.name;
     }
   }
 
   UpdateFragmentInputs();
   UpdateProgramOutputs();
+  UpdateFragmentOutputBaseTypes();
 
   valid_ = true;
 }
 
 void Program::UpdateUniforms() {
   // Reserve each client-bound uniform location. This way unbound uniforms will
   // not be allocated to locations that user expects bound uniforms to be, even
   // if the expected uniforms are optimized away by the driver.
   for (const auto& binding : bind_uniform_location_map_) {
     if (binding.second < 0)
@@ skipping 1707 matching lines @@
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 ProgramManager::ProgramManager(
     ProgramCache* program_cache,
     uint32_t max_varying_vectors,
+    uint32_t max_draw_buffers,
     uint32_t max_dual_source_draw_buffers,
     const GpuPreferences& gpu_preferences,
     FeatureInfo* feature_info)
     : program_count_(0),
       have_context_(true),
       program_cache_(program_cache),
       max_varying_vectors_(max_varying_vectors),
+      max_draw_buffers_(max_draw_buffers),
       max_dual_source_draw_buffers_(max_dual_source_draw_buffers),
       gpu_preferences_(gpu_preferences),
       feature_info_(feature_info) {}
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
@@ skipping 96 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu