Update from https://crrev.com/317530

gpu/command_buffer/client/program_info_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/client/program_info_manager.h"
 
 namespace {
 
 template<typename T> static T LocalGetAs(
     const std::vector<int8>& data, uint32 offset, size_t size) {
@@ skipping 314 matching lines @@
     // This should only happen on a lost context.
     return;
   }
   DCHECK_GE(result.size(), sizeof(ProgramInfoHeader));
   const ProgramInfoHeader* header = LocalGetAs<const ProgramInfoHeader*>(
       result, 0, sizeof(header));
   link_status_ = header->link_status != 0;
   if (!link_status_) {
     return;
   }
-  attrib_infos_.clear();
-  uniform_infos_.clear();
-  frag_data_locations_.clear();
-  max_attrib_name_length_ = 0;
-  max_uniform_name_length_ = 0;
+  DCHECK_EQ(0u, attrib_infos_.size());
+  DCHECK_EQ(0u, uniform_infos_.size());
+  DCHECK_EQ(0, max_attrib_name_length_);
+  DCHECK_EQ(0, max_uniform_name_length_);
   const ProgramInput* inputs = LocalGetAs<const ProgramInput*>(
       result, sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   const ProgramInput* input = inputs;
   for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
     const int32* location = LocalGetAs<const int32*>(
         result, input->location_offset, sizeof(int32));
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
@@ skipping 25 matching lines @@
 
 void ProgramInfoManager::Program::UpdateES3UniformBlocks(
     const std::vector<int8>& result) {
   if (cached_es3_uniform_blocks_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
-  uniform_blocks_.clear();
-  active_uniform_block_max_name_length_ = 0;
+  DCHECK_EQ(0u, uniform_blocks_.size());
+  DCHECK_EQ(0u, active_uniform_block_max_name_length_);
 
   // |result| comes from GPU process. We consider it trusted data. Therefore,
   // no need to check for overflows as the GPU side did the checks already.
   uint32_t header_size = sizeof(UniformBlocksHeader);
   DCHECK_GE(result.size(), header_size);
   const UniformBlocksHeader* header = LocalGetAs<const UniformBlocksHeader*>(
       result, 0, header_size);
   DCHECK(header);
   if (header->num_uniform_blocks == 0) {
     DCHECK_EQ(result.size(), header_size);
@@ skipping 49 matching lines @@
 
 void ProgramInfoManager::Program::UpdateES3Uniformsiv(
     const std::vector<int8>& result) {
   if (cached_es3_uniformsiv_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
-  uniforms_es3_.clear();
+  DCHECK_EQ(0u, uniforms_es3_.size());
 
   // |result| comes from GPU process. We consider it trusted data. Therefore,
   // no need to check for overflows as the GPU side did the checks already.
   uint32_t header_size = sizeof(UniformsES3Header);
   DCHECK_GE(result.size(), header_size);
   const UniformsES3Header* header = LocalGetAs<const UniformsES3Header*>(
       result, 0, header_size);
   DCHECK(header);
   if (header->num_uniforms == 0) {
     DCHECK_EQ(result.size(), header_size);
@@ skipping 21 matching lines @@
 
 void ProgramInfoManager::Program::UpdateES3TransformFeedbackVaryings(
     const std::vector<int8>& result) {
   if (cached_es3_transform_feedback_varyings_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
-  transform_feedback_varyings_.clear();
-  transform_feedback_varying_max_length_ = 0;
+  DCHECK_EQ(0u, transform_feedback_varyings_.size());
+  DCHECK_EQ(0u, transform_feedback_varying_max_length_);
 
   // |result| comes from GPU process. We consider it trusted data. Therefore,
   // no need to check for overflows as the GPU side did the checks already.
   uint32_t header_size = sizeof(TransformFeedbackVaryingsHeader);
   DCHECK_GE(result.size(), header_size);
   const TransformFeedbackVaryingsHeader* header =
       LocalGetAs<const TransformFeedbackVaryingsHeader*>(
           result, 0, header_size);
   DCHECK(header);
   if (header->num_transform_feedback_varyings == 0) {
@@ skipping 481 matching lines @@
       }
       return true;
     }
   }
   return gl->GetUniformIndicesHelper(program, count, names, indices);
 }
 
 }  // namespace gles2
 }  // namespace gpu