cc: Remove more uniform location caching

cc/output/gl_renderer.h

 // Copyright 2010 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 CC_OUTPUT_GL_RENDERER_H_
 #define CC_OUTPUT_GL_RENDERER_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 205 matching lines @@
                          const gfx::QuadF& aa_quad,
                          const gfx::QuadF* clip_region);
   void DrawContentQuadNoAA(const DrawingFrame* frame,
                            const ContentDrawQuadBase* quad,
                            ResourceId resource_id,
                            const gfx::QuadF* clip_region);
   void DrawYUVVideoQuad(const DrawingFrame* frame,
                         const YUVVideoDrawQuad* quad,
                         const gfx::QuadF* clip_region);
 
-  void SetShaderOpacity(float opacity, int alpha_location);
-  void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
+  void SetShaderOpacity(const DrawQuad* quad);
+  void SetShaderQuadF(const gfx::QuadF& quad);
+  void SetShaderMatrix(const gfx::Transform& transform);
+  void SetShaderColor(SkColor color, float opacity);
   void DrawQuadGeometryClippedByQuadF(const DrawingFrame* frame,
                                       const gfx::Transform& draw_transform,
                                       const gfx::RectF& quad_rect,
                                       const gfx::QuadF& clipping_region_quad,
-                                      int matrix_location,
                                       const float uv[8]);
   void DrawQuadGeometry(const gfx::Transform& projection_matrix,
                         const gfx::Transform& draw_transform,
-                        const gfx::RectF& quad_rect,
-                        int matrix_location);
-  void SetUseProgram(unsigned program);
+                        const gfx::RectF& quad_rect);
+  void SetUseProgram(const Program* program);
 
   bool MakeContextCurrent();
 
   void InitializeSharedObjects();
   void CleanupSharedObjects();
 
   typedef base::Callback<void(std::unique_ptr<CopyOutputRequest> copy_request,
                               bool success)>
       AsyncGetFramebufferPixelsCleanupCallback;
   void FinishedReadback(unsigned source_buffer,
@@ skipping 41 matching lines @@
   // Resources that have been sent to the GPU process, but not yet swapped.
   OverlayResourceLockList pending_overlay_resources_;
 
   // Resources that should be shortly swapped by the GPU process.
   std::deque<OverlayResourceLockList> swapping_overlay_resources_;
 
   // Resources that the GPU process has finished swapping. The key is the
   // texture id of the resource.
   std::map<unsigned, OverlayResourceLock> swapped_and_acked_overlay_resources_;
 
-  unsigned offscreen_framebuffer_id_;
+  unsigned offscreen_framebuffer_id_ = 0u;
 
   std::unique_ptr<StaticGeometryBinding> shared_geometry_;
   std::unique_ptr<DynamicGeometryBinding> clipped_geometry_;
   gfx::QuadF shared_geometry_quad_;
 
   // If the requested program has not yet been initialized, this will initialize
   // the program before returning it.
   const Program* GetProgram(const ProgramKey& key);
 
   // This will return nullptr if the requested program has not yet been
   // initialized.
   const Program* GetProgramIfInitialized(const ProgramKey& key) const;
 
   std::unordered_map<ProgramKey, std::unique_ptr<Program>, ProgramKeyHash>
       program_cache_;
 
   gpu::gles2::GLES2Interface* gl_;
   gpu::ContextSupport* context_support_;
   std::unique_ptr<ContextCacheController::ScopedVisibility> context_visibility_;
 
   TextureMailboxDeleter* texture_mailbox_deleter_;
 
   gfx::Rect swap_buffer_rect_;
   gfx::Rect scissor_rect_;
-  bool is_using_bind_uniform_;
-  bool is_scissor_enabled_;
-  bool stencil_shadow_;
-  bool blend_shadow_;
-  unsigned program_shadow_;
+  bool is_scissor_enabled_ = false;
+  bool stencil_shadow_ = false;
+  bool blend_shadow_ = false;
+  const Program* program_shadow_ = nullptr;
   TexturedQuadDrawCache draw_cache_;
-  int highp_threshold_min_;
-  int highp_threshold_cache_;
+  int highp_threshold_min_ = 0;
+  int highp_threshold_cache_ = 0;
 
   struct PendingAsyncReadPixels;
   std::vector<std::unique_ptr<PendingAsyncReadPixels>>
       pending_async_read_pixels_;
 
   std::unique_ptr<ResourceProvider::ScopedWriteLockGL>
       current_framebuffer_lock_;
   // This is valid when current_framebuffer_lock_ is not null.
   ResourceFormat current_framebuffer_format_;
 
   class SyncQuery;
   std::deque<std::unique_ptr<SyncQuery>> pending_sync_queries_;
   std::deque<std::unique_ptr<SyncQuery>> available_sync_queries_;
   std::unique_ptr<SyncQuery> current_sync_query_;
-  bool use_discard_framebuffer_;
-  bool use_sync_query_;
-  bool use_blend_equation_advanced_;
-  bool use_blend_equation_advanced_coherent_;
+  bool use_discard_framebuffer_ = false;
+  bool use_sync_query_ = false;
+  bool use_blend_equation_advanced_ = false;
+  bool use_blend_equation_advanced_coherent_ = false;
 
   // Some overlays require that content is copied from a render pass into an
   // overlay resource. This means the GLRenderer needs its own ResourcePool.
   std::unique_ptr<ResourcePool> overlay_resource_pool_;
 
   // If true, draw a green border after compositing a texture quad using GL.
   bool gl_composited_texture_quad_border_;
 
   // The method FlippedFramebuffer determines whether the framebuffer associated
   // with a DrawingFrame is flipped. It makes the assumption that the
@@ skipping 10 matching lines @@
   gfx::Size offscreen_stencil_renderbuffer_size_;
 
   base::WeakPtrFactory<GLRenderer> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_