current program can be null in ES2/ES3 contexts.

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 292 matching lines @@
       service_id_(service_id),
       deleted_(false),
       valid_(false),
       link_status_(false),
       uniforms_cleared_(false),
       transform_feedback_buffer_mode_(GL_NONE),
       fragment_output_type_mask_(0u),
       fragment_output_written_mask_(0u) {
   DCHECK(manager_);
   manager_->StartTracking(this);
+  uint32_t packed_size = manager_->max_vertex_attribs() / 16;
+  packed_size += (manager_->max_vertex_attribs() % 16 == 0) ? 0 : 1;

[piman, 2016/07/25 20:04:04]

nit: uint32_t packed_size = (manager_->max_vertex_attribs() + 15) / 16
Avoids an if test, extra modulo, and is standard pattern to round up.

+  vertex_input_base_type_mask_.resize(packed_size);
+  vertex_input_active_mask_.resize(packed_size);
+  ClearVertexInputMasks();
 }
 
 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();
   fragment_output_type_mask_ = 0u;
   fragment_output_written_mask_ = 0u;
-  vertex_input_base_type_mask_.clear();
-  vertex_input_type_written_mask_.clear();
+  ClearVertexInputMasks();
+}
+
+void Program::ClearVertexInputMasks() {
+  for (uint32_t ii = 0; ii < vertex_input_base_type_mask_.size(); ++ii) {
+    vertex_input_base_type_mask_[ii] = 0u;
+    vertex_input_active_mask_[ii] = 0u;
+  }
 }
 
 void Program::UpdateFragmentOutputBaseTypes() {
   fragment_output_type_mask_ = 0u;
   fragment_output_written_mask_ = 0u;
   Shader* fragment_shader =
       attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
   DCHECK(fragment_shader);
   for (auto const& output : fragment_shader->output_variable_list()) {
     int location = output.location;
@@ skipping 21 matching lines @@
       // "FragData0" and "FragData1" returns 0.
       int shift_bits = ii * 2;
       fragment_output_written_mask_ |= 0x3 << shift_bits;
       fragment_output_type_mask_ |=
           InputOutputTypeToBaseType(false, output.type) << shift_bits;
     }
   }
 }
 
 void Program::UpdateVertexInputBaseTypes() {
-  max_vertex_attribs_ = manager_->max_vertex_attribs();
-  uint32_t packed_size = max_vertex_attribs_ / 16;
-  packed_size += (max_vertex_attribs_ % 16 == 0) ? 0 : 1;
-  vertex_input_base_type_mask_.resize(packed_size);
-  vertex_input_type_written_mask_.resize(packed_size);

[Zhenyao Mo, 2016/07/23 16:10:40]

We don't need to resize every link because they never change size.  So move it
to Program constructor.  This probably isn't a perf gain at all, but
conceptually I feel this is cleaner.

[yunchao, 2016/07/24 04:52:13]

Acknowledged.

-
-  for (uint32_t ii = 0; ii < packed_size; ++ii) {
-    vertex_input_type_written_mask_[ii] = 0u;
-    vertex_input_base_type_mask_[ii] = 0u;
-  }
-
+  ClearVertexInputMasks();
+  DCHECK_LE(attrib_infos_.size(), manager_->max_vertex_attribs());
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
-    DCHECK(ii < max_vertex_attribs_);
     const VertexAttrib& input = attrib_infos_[ii];
     if (ProgramManager::HasBuiltInPrefix(input.name)) {
       continue;
     }
     int shift_bits = (input.location % 16) * 2;
-      vertex_input_type_written_mask_[ii / 16] |= 0x3 << shift_bits;
-      vertex_input_base_type_mask_[ii / 16] |=
-          InputOutputTypeToBaseType(true, input.type) << shift_bits;
+    vertex_input_active_mask_[ii / 16] |= 0x3 << shift_bits;
+    vertex_input_base_type_mask_[ii / 16] |=
+        InputOutputTypeToBaseType(true, input.type) << shift_bits;
   }
 }
 
 void Program::UpdateUniformBlockSizeInfo() {
   switch (feature_info().context_type()) {
     case CONTEXT_TYPE_OPENGLES2:
     case CONTEXT_TYPE_WEBGL1:
       // Uniform blocks do not exist in ES2.
       return;
     default:
@@ skipping 2129 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