Apply varying packing rule.

gpu/command_buffer/service/program_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 177 matching lines @@
 
   // Detects if there are uniforms of the same name but different type
   // or precision in vertex/fragment shaders.
   // Return true if such cases are detected.
   bool DetectUniformsMismatch() const;
 
   // Return true if a varying is statically used in fragment shader, but it
   // is not declared in vertex shader.
   bool DetectVaryingsMismatch() const;
 
+  // Return false if varyings can't be packed into the max available
+  // varying registers.
+  bool CheckVaryingsPacking() const;
+
   // Visible for testing
   const LocationMap& bind_attrib_location_map() const {
     return bind_attrib_location_map_;
   }
 
  private:
   friend class base::RefCounted<Program>;
   friend class ProgramManager;
 
   ~Program();
@@ skipping 114 matching lines @@
   // uniform-location binding map from glBindUniformLocationCHROMIUM() calls.
   LocationMap bind_uniform_location_map_;
 };
 
 // Tracks the Programs.
 //
 // NOTE: To support shared resources an instance of this class will
 // need to be shared by multiple GLES2Decoders.
 class GPU_EXPORT ProgramManager {
  public:
-  explicit ProgramManager(ProgramCache* program_cache);
+  explicit ProgramManager(ProgramCache* program_cache,
+                          uint32 max_varying_vectors);
   ~ProgramManager();
 
   // Must call before destruction.
   void Destroy(bool have_context);
 
   // Creates a new program.
   Program* CreateProgram(GLuint client_id, GLuint service_id);
 
   // Gets a program.
   Program* GetProgram(GLuint client_id);
@@ skipping 21 matching lines @@
 
   // Check if a Program is owned by this ProgramManager.
   bool IsOwned(Program* program);
 
   static int32 MakeFakeLocation(int32 index, int32 element);
 
   void DoCompileShader(Shader* shader,
                        ShaderTranslator* translator,
                        FeatureInfo* feature_info);
 
+  uint32 max_varying_vectors() const {
+    return max_varying_vectors_;
+  }
+
  private:
   friend class Program;
 
   void StartTracking(Program* program);
   void StopTracking(Program* program);
 
+  void RemoveProgramInfoIfUnused(
+      ShaderManager* shader_manager, Program* program);
+
   // Info for each "successfully linked" program by service side program Id.
   // TODO(gman): Choose a faster container.
   typedef std::map<GLuint, scoped_refptr<Program> > ProgramMap;
   ProgramMap programs_;
 
   // Counts the number of Program allocated with 'this' as its manager.
   // Allows to check no Program will outlive this.
   unsigned int program_count_;
 
   bool have_context_;
 
   bool disable_workarounds_;
 
   // Used to clear uniforms.
   std::vector<uint8> zero_;
 
   ProgramCache* program_cache_;
 
-  void RemoveProgramInfoIfUnused(
-      ShaderManager* shader_manager, Program* program);
+  uint32 max_varying_vectors_;
 
   DISALLOW_COPY_AND_ASSIGN(ProgramManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_