Remove WGC3D::isContextLost references from cc

cc/output/gl_renderer.cc

 // 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.
 
 #include "cc/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 148 matching lines @@
                        ResourceProvider* resource_provider,
                        TextureMailboxDeleter* texture_mailbox_deleter,
                        int highp_threshold_min)
     : DirectRenderer(client, settings, output_surface, resource_provider),
       offscreen_framebuffer_id_(0),
       shared_geometry_quad_(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f)),
       context_(output_surface->context_provider()->Context3d()),
       context_support_(output_surface->context_provider()->ContextSupport()),
       texture_mailbox_deleter_(texture_mailbox_deleter),
       is_backbuffer_discarded_(false),
-      is_using_bind_uniform_(false),
       visible_(true),
       is_scissor_enabled_(false),
       stencil_shadow_(false),
       blend_shadow_(false),
       highp_threshold_min_(highp_threshold_min),
       highp_threshold_cache_(0),
       on_demand_tile_raster_resource_id_(0) {
   DCHECK(context_);
   DCHECK(context_support_);
 }
@@ skipping 25 matching lines @@
   capabilities_.avoid_pow2_textures = context_caps.fast_npot_mo8_textures;
 
   capabilities_.using_offscreen_context3d = true;
 
   capabilities_.using_map_image =
       settings_->use_map_image && context_caps.map_image;
 
   capabilities_.using_discard_framebuffer =
       context_caps.discard_framebuffer;
 
-  is_using_bind_uniform_ = context_caps.bind_uniform_location;
-
   if (!InitializeSharedObjects())
     return false;
 
   // Make sure the viewport and context gets initialized, even if it is to zero.
   ViewportChanged();
   return true;
 }
 
 void GLRenderer::InitializeGrContext() {
   skia::RefPtr<GrGLInterface> interface = skia::AdoptRef(
@@ skipping 1471 matching lines @@
       bitmap_pixels,
       gfx::Rect(quad->texture_size),
       gfx::Rect(quad->texture_size),
       gfx::Vector2d());
 
   DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
 }
 
 struct TextureProgramBinding {
   template <class Program>
-  void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
-    DCHECK(program && (program->initialized() || context->isContextLost()));
+  void Set(Program* program) {
+    DCHECK(program);
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
     matrix_location = program->vertex_shader().matrix_location();
     background_color_location =
         program->fragment_shader().background_color_location();
   }
   int program_id;
   int sampler_location;
   int matrix_location;
   int background_color_location;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
   template <class Program>
-  void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
-    TextureProgramBinding::Set(program, context);
+  void Set(Program* program) {
+    TextureProgramBinding::Set(program);
     tex_transform_location = program->vertex_shader().tex_transform_location();
     vertex_opacity_location =
         program->vertex_shader().vertex_opacity_location();
   }
   int tex_transform_location;
   int vertex_opacity_location;
 };
 
 void GLRenderer::FlushTextureQuadCache() {
   // Check to see if we have anything to draw.
@@ skipping 66 matching lines @@
 void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
                                     const TextureDrawQuad* quad) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       context_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
     if (quad->background_color == SK_ColorTRANSPARENT) {
-      binding.Set(GetTextureProgram(tex_coord_precision), Context());
+      binding.Set(GetTextureProgram(tex_coord_precision));
     } else {
-      binding.Set(GetTextureBackgroundProgram(tex_coord_precision), Context());
+      binding.Set(GetTextureBackgroundProgram(tex_coord_precision));
     }
   } else {
     if (quad->background_color == SK_ColorTRANSPARENT) {
-      binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision),
-                  Context());
+      binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision));
     } else {
       binding.Set(
-          GetNonPremultipliedTextureBackgroundProgram(tex_coord_precision),
-          Context());
+          GetNonPremultipliedTextureBackgroundProgram(tex_coord_precision));
     }
   }
 
   int resource_id = quad->resource_id;
 
   if (draw_cache_.program_id != binding.program_id ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
       draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= 8) {
@@ skipping 32 matching lines @@
 
 void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
                                    const IOSurfaceDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       context_,  &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   TexTransformTextureProgramBinding binding;
-  binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision), Context());
+  binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision));
 
   SetUseProgram(binding.program_id);
   GLC(Context(), Context()->uniform1i(binding.sampler_location, 0));
   if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) {
     GLC(Context(),
         Context()->uniform4f(binding.tex_transform_location,
                              0,
                              quad->io_surface_size.height(),
                              quad->io_surface_size.width(),
                              quad->io_surface_size.height() * -1.0f));
@@ skipping 622 matching lines @@
 
 bool GLRenderer::MakeContextCurrent() { return context_->makeContextCurrent(); }
 
 bool GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
   MakeContextCurrent();
 
   // Create an FBO for doing offscreen rendering.
   GLC(context_, offscreen_framebuffer_id_ = context_->createFramebuffer());
 
-  // We will always need these programs to render, so create the programs
-  // eagerly so that the shader compilation can start while we do other work.
-  // Other programs are created lazily on first access.
   shared_geometry_ = make_scoped_ptr(
       new GeometryBinding(context_, QuadVertexRect()));
-  render_pass_program_ = make_scoped_ptr(
-      new RenderPassProgram(context_, TexCoordPrecisionMedium));
-  render_pass_program_highp_ = make_scoped_ptr(
-      new RenderPassProgram(context_, TexCoordPrecisionHigh));
-  tile_program_ = make_scoped_ptr(
-      new TileProgram(context_, TexCoordPrecisionMedium));
-  tile_program_opaque_ = make_scoped_ptr(
-      new TileProgramOpaque(context_, TexCoordPrecisionMedium));
-  tile_program_highp_ = make_scoped_ptr(
-      new TileProgram(context_, TexCoordPrecisionHigh));
-  tile_program_opaque_highp_ = make_scoped_ptr(
-      new TileProgramOpaque(context_, TexCoordPrecisionHigh));
+  // We will always need these programs to render, so initialize the programs
+  // eagerly so that the shader compilation can start while we do other work.
+  // Other programs are initialized lazily on first access.
+  render_pass_program_.Initialize(output_surface_->context_provider(),
+                                  TexCoordPrecisionMedium);
+  render_pass_program_highp_.Initialize(output_surface_->context_provider(),
+                                        TexCoordPrecisionHigh);
+  tile_program_.Initialize(output_surface_->context_provider(),
+                           TexCoordPrecisionMedium);
+  tile_program_opaque_.Initialize(output_surface_->context_provider(),
+                                  TexCoordPrecisionMedium);
+  tile_program_highp_.Initialize(output_surface_->context_provider(),
+                                 TexCoordPrecisionHigh);
+  tile_program_opaque_highp_.Initialize(output_surface_->context_provider(),
+                                        TexCoordPrecisionHigh);
 
   GLC(context_, context_->flush());
 
   return true;
 }
 
 const GLRenderer::TileCheckerboardProgram*
 GLRenderer::GetTileCheckerboardProgram() {
-  if (!tile_checkerboard_program_)
-    tile_checkerboard_program_ = make_scoped_ptr(
-        new TileCheckerboardProgram(context_, TexCoordPrecisionNA));
-  if (!tile_checkerboard_program_->initialized()) {
+  if (!tile_checkerboard_program_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::checkerboardProgram::initalize");
-    tile_checkerboard_program_->Initialize(context_, is_using_bind_uniform_);
-  }
-  return tile_checkerboard_program_.get();
+    tile_checkerboard_program_.Initialize(
+        output_surface_->context_provider(), TexCoordPrecisionNA);
+  }
+  return &tile_checkerboard_program_;
 }
 
 const GLRenderer::DebugBorderProgram* GLRenderer::GetDebugBorderProgram() {
-  if (!debug_border_program_)
-    debug_border_program_ = make_scoped_ptr(
-        new DebugBorderProgram(context_, TexCoordPrecisionNA));
-  if (!debug_border_program_->initialized()) {
+  if (!debug_border_program_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::debugBorderProgram::initialize");
-    debug_border_program_->Initialize(context_, is_using_bind_uniform_);
-  }
-  return debug_border_program_.get();
+    debug_border_program_.Initialize(
+        output_surface_->context_provider(), TexCoordPrecisionNA);
+  }
+  return &debug_border_program_;
 }
 
 const GLRenderer::SolidColorProgram* GLRenderer::GetSolidColorProgram() {
-  if (!solid_color_program_)
-    solid_color_program_ = make_scoped_ptr(
-        new SolidColorProgram(context_, TexCoordPrecisionNA));
-  if (!solid_color_program_->initialized()) {
+  if (!solid_color_program_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::solidColorProgram::initialize");
-    solid_color_program_->Initialize(context_, is_using_bind_uniform_);
-  }
-  return solid_color_program_.get();
+    solid_color_program_.Initialize(
+        output_surface_->context_provider(), TexCoordPrecisionNA);
+  }
+  return &solid_color_program_;
 }
 
 const GLRenderer::SolidColorProgramAA* GLRenderer::GetSolidColorProgramAA() {
-  if (!solid_color_program_aa_) {
-    solid_color_program_aa_ =
-        make_scoped_ptr(new SolidColorProgramAA(context_, TexCoordPrecisionNA));
-  }
-  if (!solid_color_program_aa_->initialized()) {
+  if (!solid_color_program_aa_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::solidColorProgramAA::initialize");
-    solid_color_program_aa_->Initialize(context_, is_using_bind_uniform_);
-  }
-  return solid_color_program_aa_.get();
+    solid_color_program_aa_.Initialize(
+        output_surface_->context_provider(), TexCoordPrecisionNA);
+  }
+  return &solid_color_program_aa_;
 }
 
 const GLRenderer::RenderPassProgram* GLRenderer::GetRenderPassProgram(
       TexCoordPrecision precision) {
-  scoped_ptr<RenderPassProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? render_pass_program_highp_
-                                           : render_pass_program_;
-  DCHECK(program);
+  RenderPassProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &render_pass_program_highp_
+                                           : &render_pass_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassProgramAA* GLRenderer::GetRenderPassProgramAA(
       TexCoordPrecision precision) {
-  scoped_ptr<RenderPassProgramAA>& program =
-      (precision == TexCoordPrecisionHigh) ? render_pass_program_aa_highp_
-                                           : render_pass_program_aa_;
-  if (!program)
-    program =
-        make_scoped_ptr(new RenderPassProgramAA(context_, precision));
+  RenderPassProgramAA* program =
+      (precision == TexCoordPrecisionHigh) ? &render_pass_program_aa_highp_
+                                           : &render_pass_program_aa_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassProgramAA::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassMaskProgram*
 GLRenderer::GetRenderPassMaskProgram(TexCoordPrecision precision) {
-  scoped_ptr<RenderPassMaskProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? render_pass_mask_program_highp_
-                                           : render_pass_mask_program_;
-  if (!program)
-    program = make_scoped_ptr(new RenderPassMaskProgram(context_, precision));
+  RenderPassMaskProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &render_pass_mask_program_highp_
+                                           : &render_pass_mask_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassMaskProgramAA*
 GLRenderer::GetRenderPassMaskProgramAA(TexCoordPrecision precision) {
-  scoped_ptr<RenderPassMaskProgramAA>& program =
-      (precision == TexCoordPrecisionHigh) ? render_pass_mask_program_aa_highp_
-                                           : render_pass_mask_program_aa_;
-  if (!program)
-    program =
-        make_scoped_ptr(new RenderPassMaskProgramAA(context_, precision));
+  RenderPassMaskProgramAA* program =
+      (precision == TexCoordPrecisionHigh) ? &render_pass_mask_program_aa_highp_
+                                           : &render_pass_mask_program_aa_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgramAA::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassColorMatrixProgram*
 GLRenderer::GetRenderPassColorMatrixProgram(TexCoordPrecision precision) {
-  scoped_ptr<RenderPassColorMatrixProgram>& program =
-      (precision == TexCoordPrecisionHigh) ?
-          render_pass_color_matrix_program_highp_ :
-          render_pass_color_matrix_program_;
-  if (!program)
-    program = make_scoped_ptr(
-        new RenderPassColorMatrixProgram(context_, precision));
+  RenderPassColorMatrixProgram* program =
+      (precision == TexCoordPrecisionHigh) ?
+          &render_pass_color_matrix_program_highp_ :
+          &render_pass_color_matrix_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassColorMatrixProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassColorMatrixProgramAA*
 GLRenderer::GetRenderPassColorMatrixProgramAA(TexCoordPrecision precision) {
-  scoped_ptr<RenderPassColorMatrixProgramAA>& program =
-      (precision == TexCoordPrecisionHigh) ?
-          render_pass_color_matrix_program_aa_highp_ :
-          render_pass_color_matrix_program_aa_;
-  if (!program)
-    program = make_scoped_ptr(
-        new RenderPassColorMatrixProgramAA(context_, precision));
+  RenderPassColorMatrixProgramAA* program =
+      (precision == TexCoordPrecisionHigh) ?
+          &render_pass_color_matrix_program_aa_highp_ :
+          &render_pass_color_matrix_program_aa_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassColorMatrixProgramAA::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassMaskColorMatrixProgram*
 GLRenderer::GetRenderPassMaskColorMatrixProgram(TexCoordPrecision precision) {
-  scoped_ptr<RenderPassMaskColorMatrixProgram>& program =
-      (precision == TexCoordPrecisionHigh) ?
-          render_pass_mask_color_matrix_program_highp_ :
-          render_pass_mask_color_matrix_program_;
-  if (!program)
-    program = make_scoped_ptr(
-        new RenderPassMaskColorMatrixProgram(context_, precision));
+  RenderPassMaskColorMatrixProgram* program =
+      (precision == TexCoordPrecisionHigh) ?
+          &render_pass_mask_color_matrix_program_highp_ :
+          &render_pass_mask_color_matrix_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassMaskColorMatrixProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::RenderPassMaskColorMatrixProgramAA*
 GLRenderer::GetRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision) {
-  scoped_ptr<RenderPassMaskColorMatrixProgramAA>& program =
-      (precision == TexCoordPrecisionHigh) ?
-          render_pass_mask_color_matrix_program_aa_highp_ :
-          render_pass_mask_color_matrix_program_aa_;
-  if (!program)
-    program = make_scoped_ptr(
-        new RenderPassMaskColorMatrixProgramAA(context_, precision));
+  RenderPassMaskColorMatrixProgramAA* program =
+      (precision == TexCoordPrecisionHigh) ?
+          &render_pass_mask_color_matrix_program_aa_highp_ :
+          &render_pass_mask_color_matrix_program_aa_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassMaskColorMatrixProgramAA::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TileProgram* GLRenderer::GetTileProgram(
     TexCoordPrecision precision) {
-  scoped_ptr<TileProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? tile_program_highp_
-                                           : tile_program_;
+  TileProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &tile_program_highp_
+                                           : &tile_program_;
+  if (!program->initialized()) {
+    TRACE_EVENT0("cc", "GLRenderer::tileProgram::initialize");
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
+}
+
+const GLRenderer::TileProgramOpaque* GLRenderer::GetTileProgramOpaque(
+    TexCoordPrecision precision) {
+  TileProgramOpaque* program =
+      (precision == TexCoordPrecisionHigh) ? &tile_program_opaque_highp_
+                                           : &tile_program_opaque_;
   DCHECK(program);
   if (!program->initialized()) {
-    TRACE_EVENT0("cc", "GLRenderer::tileProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
-}
-
-const GLRenderer::TileProgramOpaque* GLRenderer::GetTileProgramOpaque(
-    TexCoordPrecision precision) {
-  scoped_ptr<TileProgramOpaque>& program =
-      (precision == TexCoordPrecisionHigh) ? tile_program_opaque_highp_
-                                           : tile_program_opaque_;
-  DCHECK(program);
-  if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::tileProgramOpaque::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TileProgramAA* GLRenderer::GetTileProgramAA(
     TexCoordPrecision precision) {
-  scoped_ptr<TileProgramAA>& program =
-      (precision == TexCoordPrecisionHigh) ? tile_program_aa_highp_
-                                           : tile_program_aa_;
-  if (!program)
-    program = make_scoped_ptr(new TileProgramAA(context_, precision));
+  TileProgramAA* program =
+      (precision == TexCoordPrecisionHigh) ? &tile_program_aa_highp_
+                                           : &tile_program_aa_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::tileProgramAA::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TileProgramSwizzle* GLRenderer::GetTileProgramSwizzle(
     TexCoordPrecision precision) {
-  scoped_ptr<TileProgramSwizzle>& program =
-      (precision == TexCoordPrecisionHigh) ? tile_program_swizzle_highp_
-                                           : tile_program_swizzle_;
-  if (!program)
-    program = make_scoped_ptr(new TileProgramSwizzle(context_, precision));
+  TileProgramSwizzle* program =
+      (precision == TexCoordPrecisionHigh) ? &tile_program_swizzle_highp_
+                                           : &tile_program_swizzle_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzle::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TileProgramSwizzleOpaque*
 GLRenderer::GetTileProgramSwizzleOpaque(TexCoordPrecision precision) {
-  scoped_ptr<TileProgramSwizzleOpaque>& program =
-      (precision == TexCoordPrecisionHigh) ? tile_program_swizzle_opaque_highp_
-                                           : tile_program_swizzle_opaque_;
-  if (!program)
-    program = make_scoped_ptr(
-        new TileProgramSwizzleOpaque(context_, precision));
+  TileProgramSwizzleOpaque* program =
+      (precision == TexCoordPrecisionHigh) ? &tile_program_swizzle_opaque_highp_
+                                           : &tile_program_swizzle_opaque_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleOpaque::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TileProgramSwizzleAA* GLRenderer::GetTileProgramSwizzleAA(
     TexCoordPrecision precision) {
-  scoped_ptr<TileProgramSwizzleAA>& program =
-      (precision == TexCoordPrecisionHigh) ? tile_program_swizzle_aa_highp_
-                                           : tile_program_swizzle_aa_;
-  if (!program)
-    program = make_scoped_ptr(new TileProgramSwizzleAA(context_, precision));
+  TileProgramSwizzleAA* program =
+      (precision == TexCoordPrecisionHigh) ? &tile_program_swizzle_aa_highp_
+                                           : &tile_program_swizzle_aa_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleAA::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TextureProgram* GLRenderer::GetTextureProgram(
     TexCoordPrecision precision) {
-  scoped_ptr<TextureProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? texture_program_highp_
-                                           : texture_program_;
-  if (!program)
-    program = make_scoped_ptr(new TextureProgram(context_, precision));
+  TextureProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &texture_program_highp_
+                                           : &texture_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::NonPremultipliedTextureProgram*
     GLRenderer::GetNonPremultipliedTextureProgram(TexCoordPrecision precision) {
-  scoped_ptr<NonPremultipliedTextureProgram>& program =
-      (precision == TexCoordPrecisionHigh) ?
-         nonpremultiplied_texture_program_highp_ :
-         nonpremultiplied_texture_program_;
-  if (!program) {
-    program = make_scoped_ptr(
-        new NonPremultipliedTextureProgram(context_, precision));
-  }
+  NonPremultipliedTextureProgram* program =
+      (precision == TexCoordPrecisionHigh) ?
+         &nonpremultiplied_texture_program_highp_ :
+         &nonpremultiplied_texture_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::NonPremultipliedTextureProgram::Initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TextureBackgroundProgram*
 GLRenderer::GetTextureBackgroundProgram(TexCoordPrecision precision) {
-  scoped_ptr<TextureBackgroundProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? texture_background_program_highp_
-                                           : texture_background_program_;
-  if (!program) {
-    program = make_scoped_ptr(
-        new TextureBackgroundProgram(context_, precision));
-  }
+  TextureBackgroundProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &texture_background_program_highp_
+                                           : &texture_background_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::NonPremultipliedTextureBackgroundProgram*
 GLRenderer::GetNonPremultipliedTextureBackgroundProgram(
     TexCoordPrecision precision) {
-  scoped_ptr<NonPremultipliedTextureBackgroundProgram>& program =
-      (precision == TexCoordPrecisionHigh) ?
-         nonpremultiplied_texture_background_program_highp_ :
-         nonpremultiplied_texture_background_program_;
-  if (!program) {
-    program = make_scoped_ptr(
-        new NonPremultipliedTextureBackgroundProgram(context_, precision));
-  }
+  NonPremultipliedTextureBackgroundProgram* program =
+      (precision == TexCoordPrecisionHigh) ?
+         &nonpremultiplied_texture_background_program_highp_ :
+         &nonpremultiplied_texture_background_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::NonPremultipliedTextureProgram::Initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::TextureIOSurfaceProgram*
 GLRenderer::GetTextureIOSurfaceProgram(TexCoordPrecision precision) {
-  scoped_ptr<TextureIOSurfaceProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? texture_io_surface_program_highp_
-                                           : texture_io_surface_program_;
-  if (!program)
-    program =
-        make_scoped_ptr(new TextureIOSurfaceProgram(context_, precision));
+  TextureIOSurfaceProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &texture_io_surface_program_highp_
+                                           : &texture_io_surface_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::VideoYUVProgram* GLRenderer::GetVideoYUVProgram(
     TexCoordPrecision precision) {
-  scoped_ptr<VideoYUVProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? video_yuv_program_highp_
-                                           : video_yuv_program_;
-  if (!program)
-    program = make_scoped_ptr(new VideoYUVProgram(context_, precision));
+  VideoYUVProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &video_yuv_program_highp_
+                                           : &video_yuv_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::VideoYUVAProgram* GLRenderer::GetVideoYUVAProgram(
     TexCoordPrecision precision) {
-  scoped_ptr<VideoYUVAProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? video_yuva_program_highp_
-                                           : video_yuva_program_;
-  if (!program)
-    program = make_scoped_ptr(new VideoYUVAProgram(context_, precision));
+  VideoYUVAProgram* program =
+      (precision == TexCoordPrecisionHigh) ? &video_yuva_program_highp_
+                                           : &video_yuva_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVAProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 const GLRenderer::VideoStreamTextureProgram*
 GLRenderer::GetVideoStreamTextureProgram(TexCoordPrecision precision) {
   if (!Capabilities().using_egl_image)
     return NULL;
-  scoped_ptr<VideoStreamTextureProgram>& program =
-      (precision == TexCoordPrecisionHigh) ? video_stream_texture_program_highp_
-                                           : video_stream_texture_program_;
-  if (!program)
-    program =
-        make_scoped_ptr(new VideoStreamTextureProgram(context_, precision));
+  VideoStreamTextureProgram* program = (precision == TexCoordPrecisionHigh)
+      ? &video_stream_texture_program_highp_
+      : &video_stream_texture_program_;
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::streamTextureProgram::initialize");
-    program->Initialize(context_, is_using_bind_uniform_);
-  }
-  return program.get();
+    program->Initialize(output_surface_->context_provider(), precision);
+  }
+  return program;
 }
 
 void GLRenderer::CleanupSharedObjects() {
   MakeContextCurrent();
 
   shared_geometry_.reset();
 
-  if (tile_program_)
-    tile_program_->Cleanup(context_);
-  if (tile_program_opaque_)
-    tile_program_opaque_->Cleanup(context_);
-  if (tile_program_swizzle_)
-    tile_program_swizzle_->Cleanup(context_);
-  if (tile_program_swizzle_opaque_)
-    tile_program_swizzle_opaque_->Cleanup(context_);
-  if (tile_program_aa_)
-    tile_program_aa_->Cleanup(context_);
-  if (tile_program_swizzle_aa_)
-    tile_program_swizzle_aa_->Cleanup(context_);
-  if (tile_checkerboard_program_)
-    tile_checkerboard_program_->Cleanup(context_);
+  tile_program_.Cleanup(context_);
+  tile_program_opaque_.Cleanup(context_);
+  tile_program_swizzle_.Cleanup(context_);
+  tile_program_swizzle_opaque_.Cleanup(context_);
+  tile_program_aa_.Cleanup(context_);
+  tile_program_swizzle_aa_.Cleanup(context_);
+  tile_checkerboard_program_.Cleanup(context_);
 
-  if (tile_program_highp_)
-    tile_program_highp_->Cleanup(context_);
-  if (tile_program_opaque_highp_)
-    tile_program_opaque_highp_->Cleanup(context_);
-  if (tile_program_swizzle_highp_)
-    tile_program_swizzle_highp_->Cleanup(context_);
-  if (tile_program_swizzle_opaque_highp_)
-    tile_program_swizzle_opaque_highp_->Cleanup(context_);
-  if (tile_program_aa_highp_)
-    tile_program_aa_highp_->Cleanup(context_);
-  if (tile_program_swizzle_aa_highp_)
-    tile_program_swizzle_aa_highp_->Cleanup(context_);
+  tile_program_highp_.Cleanup(context_);
+  tile_program_opaque_highp_.Cleanup(context_);
+  tile_program_swizzle_highp_.Cleanup(context_);
+  tile_program_swizzle_opaque_highp_.Cleanup(context_);
+  tile_program_aa_highp_.Cleanup(context_);
+  tile_program_swizzle_aa_highp_.Cleanup(context_);
 
-  if (render_pass_mask_program_)
-    render_pass_mask_program_->Cleanup(context_);
-  if (render_pass_program_)
-    render_pass_program_->Cleanup(context_);
-  if (render_pass_mask_program_aa_)
-    render_pass_mask_program_aa_->Cleanup(context_);
-  if (render_pass_program_aa_)
-    render_pass_program_aa_->Cleanup(context_);
-  if (render_pass_color_matrix_program_)
-    render_pass_color_matrix_program_->Cleanup(context_);
-  if (render_pass_mask_color_matrix_program_aa_)
-    render_pass_mask_color_matrix_program_aa_->Cleanup(context_);
-  if (render_pass_color_matrix_program_aa_)
-    render_pass_color_matrix_program_aa_->Cleanup(context_);
-  if (render_pass_mask_color_matrix_program_)
-    render_pass_mask_color_matrix_program_->Cleanup(context_);
+  render_pass_mask_program_.Cleanup(context_);
+  render_pass_program_.Cleanup(context_);
+  render_pass_mask_program_aa_.Cleanup(context_);
+  render_pass_program_aa_.Cleanup(context_);
+  render_pass_color_matrix_program_.Cleanup(context_);
+  render_pass_mask_color_matrix_program_aa_.Cleanup(context_);
+  render_pass_color_matrix_program_aa_.Cleanup(context_);
+  render_pass_mask_color_matrix_program_.Cleanup(context_);
 
-  if (render_pass_mask_program_highp_)
-    render_pass_mask_program_highp_->Cleanup(context_);
-  if (render_pass_program_highp_)
-    render_pass_program_highp_->Cleanup(context_);
-  if (render_pass_mask_program_aa_highp_)
-    render_pass_mask_program_aa_highp_->Cleanup(context_);
-  if (render_pass_program_aa_highp_)
-    render_pass_program_aa_highp_->Cleanup(context_);
-  if (render_pass_color_matrix_program_highp_)
-    render_pass_color_matrix_program_highp_->Cleanup(context_);
-  if (render_pass_mask_color_matrix_program_aa_highp_)
-    render_pass_mask_color_matrix_program_aa_highp_->Cleanup(context_);
-  if (render_pass_color_matrix_program_aa_highp_)
-    render_pass_color_matrix_program_aa_highp_->Cleanup(context_);
-  if (render_pass_mask_color_matrix_program_highp_)
-    render_pass_mask_color_matrix_program_highp_->Cleanup(context_);
+  render_pass_mask_program_highp_.Cleanup(context_);
+  render_pass_program_highp_.Cleanup(context_);
+  render_pass_mask_program_aa_highp_.Cleanup(context_);
+  render_pass_program_aa_highp_.Cleanup(context_);
+  render_pass_color_matrix_program_highp_.Cleanup(context_);
+  render_pass_mask_color_matrix_program_aa_highp_.Cleanup(context_);
+  render_pass_color_matrix_program_aa_highp_.Cleanup(context_);
+  render_pass_mask_color_matrix_program_highp_.Cleanup(context_);
 
-  if (texture_program_)
-    texture_program_->Cleanup(context_);
-  if (nonpremultiplied_texture_program_)
-    nonpremultiplied_texture_program_->Cleanup(context_);
-  if (texture_background_program_)
-    texture_background_program_->Cleanup(context_);
-  if (nonpremultiplied_texture_background_program_)
-    nonpremultiplied_texture_background_program_->Cleanup(context_);
-  if (texture_io_surface_program_)
-    texture_io_surface_program_->Cleanup(context_);
+  texture_program_.Cleanup(context_);
+  nonpremultiplied_texture_program_.Cleanup(context_);
+  texture_background_program_.Cleanup(context_);
+  nonpremultiplied_texture_background_program_.Cleanup(context_);
+  texture_io_surface_program_.Cleanup(context_);
 
-  if (texture_program_highp_)
-    texture_program_highp_->Cleanup(context_);
-  if (nonpremultiplied_texture_program_highp_)
-    nonpremultiplied_texture_program_highp_->Cleanup(context_);
-  if (texture_background_program_highp_)
-    texture_background_program_highp_->Cleanup(context_);
-  if (nonpremultiplied_texture_background_program_highp_)
-    nonpremultiplied_texture_background_program_highp_->Cleanup(context_);
-  if (texture_io_surface_program_highp_)
-    texture_io_surface_program_highp_->Cleanup(context_);
+  texture_program_highp_.Cleanup(context_);
+  nonpremultiplied_texture_program_highp_.Cleanup(context_);
+  texture_background_program_highp_.Cleanup(context_);
+  nonpremultiplied_texture_background_program_highp_.Cleanup(context_);
+  texture_io_surface_program_highp_.Cleanup(context_);
 
-  if (video_yuv_program_)
-    video_yuv_program_->Cleanup(context_);
-  if (video_yuva_program_)
-    video_yuva_program_->Cleanup(context_);
-  if (video_stream_texture_program_)
-    video_stream_texture_program_->Cleanup(context_);
+  video_yuv_program_.Cleanup(context_);
+  video_yuva_program_.Cleanup(context_);
+  video_stream_texture_program_.Cleanup(context_);
 
-  if (video_yuv_program_highp_)
-    video_yuv_program_highp_->Cleanup(context_);
-  if (video_yuva_program_highp_)
-    video_yuva_program_highp_->Cleanup(context_);
-  if (video_stream_texture_program_highp_)
-    video_stream_texture_program_highp_->Cleanup(context_);
+  video_yuv_program_highp_.Cleanup(context_);
+  video_yuva_program_highp_.Cleanup(context_);
+  video_stream_texture_program_highp_.Cleanup(context_);
 
-  if (debug_border_program_)
-    debug_border_program_->Cleanup(context_);
-  if (solid_color_program_)
-    solid_color_program_->Cleanup(context_);
-  if (solid_color_program_aa_)
-    solid_color_program_aa_->Cleanup(context_);
+  debug_border_program_.Cleanup(context_);
+  solid_color_program_.Cleanup(context_);
+  solid_color_program_aa_.Cleanup(context_);
 
   if (offscreen_framebuffer_id_)
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   if (on_demand_tile_raster_resource_id_)
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
@@ skipping 37 matching lines @@
   GLC(context_, context_->disable(GL_SCISSOR_TEST));
 }
 
 bool GLRenderer::CanUseSkiaGPUBackend() const {
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
-  return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
+  return output_surface_->context_provider()->IsContextLost();
 }
 
 }  // namespace cc