Update from https://crrev.com/320931

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 <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 193 matching lines @@
 Program::Program(ProgramManager* manager, GLuint service_id)
     : 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),
-      num_uniforms_(0) {
+      num_uniforms_(0),
+      transform_feedback_buffer_mode_(GL_NONE) {
   manager_->StartTracking(this);
 }
 
 void Program::Reset() {
   valid_ = false;
   link_status_ = false;
   num_uniforms_ = 0;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
@@ skipping 300 matching lines @@
 
   TimeTicks before_time = TimeTicks::Now();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     DCHECK(!attached_shaders_[0]->last_compiled_source().empty() &&
            !attached_shaders_[1]->last_compiled_source().empty());
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
         attached_shaders_[0]->last_compiled_signature(),
         attached_shaders_[1]->last_compiled_signature(),
-        &bind_attrib_location_map_);
+        &bind_attrib_location_map_,
+        transform_feedback_varyings_,
+        transform_feedback_buffer_mode_);
 
     if (status == ProgramCache::LINK_SUCCEEDED) {
       ProgramCache::ProgramLoadResult success =
           cache->LoadLinkedProgram(service_id(),
                                    attached_shaders_[0].get(),
                                    attached_shaders_[1].get(),
                                    &bind_attrib_location_map_,
+                                   transform_feedback_varyings_,
+                                   transform_feedback_buffer_mode_,
                                    shader_callback);
       link = success != ProgramCache::PROGRAM_LOAD_SUCCESS;
       UMA_HISTOGRAM_BOOLEAN("GPU.ProgramCache.LoadBinarySuccess", !link);
     }
   }
 
   if (link) {
     CompileAttachedShaders();
 
     if (!CanLink()) {
@@ skipping 48 matching lines @@
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
   if (success == GL_TRUE) {
     Update();
     if (link) {
       if (cache) {
         cache->SaveLinkedProgram(service_id(),
                                  attached_shaders_[0].get(),
                                  attached_shaders_[1].get(),
                                  &bind_attrib_location_map_,
+                                 transform_feedback_varyings_,
+                                 transform_feedback_buffer_mode_,
                                  shader_callback);
       }
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "GPU.ProgramCache.BinaryCacheMissTime",
           static_cast<base::HistogramBase::Sample>(
               (TimeTicks::Now() - before_time).InMicroseconds()),
           0,
           static_cast<base::HistogramBase::Sample>(
               TimeDelta::FromSeconds(10).InMicroseconds()),
           50);
@@ skipping 975 matching lines @@
     }
     glGetActiveUniformsiv(
         program, count, &indices[0], kPname[pname_index], &params[0]);
     for (GLsizei ii = 0; ii < count; ++ii) {
       entries[kStride * ii + pname_index] = params[ii];
     }
   }
   return true;
 }
 
+void Program::TransformFeedbackVaryings(GLsizei count,
+                                        const char* const* varyings,
+                                        GLenum buffer_mode) {
+  transform_feedback_varyings_.clear();
+  for (GLsizei i = 0; i < count; ++i) {
+    transform_feedback_varyings_.push_back(std::string(varyings[i]));
+  }
+  transform_feedback_buffer_mode_ = buffer_mode;
+}
+
 Program::~Program() {
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
@@ skipping 112 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu