cc: Remove most methods from RendererClient.

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 109 matching lines @@
 
   scoped_ptr<CopyOutputRequest> copy_request;
   base::CancelableClosure finished_read_pixels_callback;
   unsigned buffer;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PendingAsyncReadPixels);
 };
 
 scoped_ptr<GLRenderer> GLRenderer::Create(RendererClient* client,
+                                          const LayerTreeSettings* settings,
                                           OutputSurface* output_surface,
                                           ResourceProvider* resource_provider,
                                           int highp_threshold_min,
                                           bool use_skia_gpu_backend) {
-  scoped_ptr<GLRenderer> renderer(new GLRenderer(
-      client, output_surface, resource_provider, highp_threshold_min));
+  scoped_ptr<GLRenderer> renderer(new GLRenderer(client,
+                                                 settings,
+                                                 output_surface,
+                                                 resource_provider,
+                                                 highp_threshold_min));
   if (!renderer->Initialize())
     return scoped_ptr<GLRenderer>();
   if (use_skia_gpu_backend) {
     renderer->InitializeGrContext();
     DCHECK(renderer->CanUseSkiaGPUBackend())
         << "Requested Skia GPU backend, but can't use it.";
   }
 
   return renderer.Pass();
 }
 
 GLRenderer::GLRenderer(RendererClient* client,
+                       const LayerTreeSettings* settings,
                        OutputSurface* output_surface,
                        ResourceProvider* resource_provider,
                        int highp_threshold_min)
-    : DirectRenderer(client, output_surface, resource_provider),
+    : 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()),
       is_backbuffer_discarded_(false),
       discard_backbuffer_when_not_visible_(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),
       offscreen_context_labelled_(false),
       on_demand_tile_raster_resource_id_(0) {
   DCHECK(context_);
 }
 
 bool GLRenderer::Initialize() {
   if (!context_->makeContextCurrent())
     return false;
 
-  std::string unique_context_name = base::StringPrintf(
-      "%s-%p",
-      Settings().compositor_name.c_str(),
-      context_);
+  std::string unique_context_name =
+      base::StringPrintf("%s-%p", settings_->compositor_name.c_str(), context_);
   context_->pushGroupMarkerEXT(unique_context_name.c_str());
 
   ContextProvider::Capabilities context_caps =
     output_surface_->context_provider()->ContextCapabilities();
 
   capabilities_.using_partial_swap =
-      Settings().partial_swap_enabled &&
-      context_caps.post_sub_buffer;
+      settings_->partial_swap_enabled && context_caps.post_sub_buffer;
 
   capabilities_.using_set_visibility = context_caps.set_visibility;
 
   DCHECK(!context_caps.iosurface || context_caps.texture_rectangle);
 
   capabilities_.using_egl_image = context_caps.egl_image_external;
 
   capabilities_.max_texture_size = resource_provider_->max_texture_size();
   capabilities_.best_texture_format = resource_provider_->best_texture_format();
 
   // The updater can access textures while the GLRenderer is using them.
   capabilities_.allow_partial_texture_updates = true;
 
   // Check for texture fast paths. Currently we always use MO8 textures,
   // so we only need to avoid POT textures if we have an NPOT fast-path.
   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;
+      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.
@@ skipping 67 matching lines @@
 
 void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }
 
 void GLRenderer::ViewportChanged() {
   ReinitializeGrCanvas();
 }
 
 void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {
   // It's unsafe to clear when we have a stencil test because glClear ignores
   // stencil.
-  if (client_->ExternalStencilTestEnabled() &&
+  if (output_surface_->HasExternalStencilTest() &&
       frame->current_render_pass == frame->root_render_pass) {
     DCHECK(!frame->current_render_pass->has_transparent_background);
     return;
   }
 
   if (capabilities_.using_discard_framebuffer) {
     GLenum attachments[] = {
         GL_COLOR_EXT
     };
     context_->discardFramebufferEXT(
@@ skipping 938 matching lines @@
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
   bool use_aa =
-      Settings().allow_antialiasing && !quad->force_anti_aliasing_off &&
+      settings_->allow_antialiasing && !quad->force_anti_aliasing_off &&
       SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
   if (use_aa)
     SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms);
   else
     SolidColorUniformLocation(GetSolidColorProgram(), &uniforms);
   SetUseProgram(uniforms.program);
 
   GLC(Context(),
@@ skipping 118 matching lines @@
   float fragment_tex_scale_y = clamp_tex_rect.height() / texture_size.height();
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
-  bool use_aa = Settings().allow_antialiasing && SetupQuadForAntialiasing(
+  bool use_aa = settings_->allow_antialiasing && SetupQuadForAntialiasing(
       device_transform, quad, &local_quad, edge);
 
   TileProgramUniforms uniforms;
   if (use_aa) {
     if (quad->swizzle_contents) {
       TileUniformLocation(GetTileProgramSwizzleAA(tex_coord_precision),
                           &uniforms);
     } else {
       TileUniformLocation(GetTileProgramAA(tex_coord_precision), &uniforms);
     }
@@ skipping 689 matching lines @@
   DCHECK(visible_);
   DCHECK(!is_backbuffer_discarded_);
 
   TRACE_EVENT0("cc", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
   CompositorFrame compositor_frame;
   compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
   compositor_frame.gl_frame_data = make_scoped_ptr(new GLFrameData);
   compositor_frame.gl_frame_data->size = output_surface_->SurfaceSize();
-  if (capabilities_.using_partial_swap && client_->AllowPartialSwap()) {
+  if (capabilities_.using_partial_swap) {
     // If supported, we can save significant bandwidth by only swapping the
     // damaged/scissored region (clamped to the viewport)
     swap_buffer_rect_.Intersect(client_->DeviceViewport());
     int flipped_y_pos_of_rect_bottom =
         client_->DeviceViewport().height() - swap_buffer_rect_.y() -
         swap_buffer_rect_.height();
     compositor_frame.gl_frame_data->sub_buffer_rect =
         gfx::Rect(swap_buffer_rect_.x(),
                   flipped_y_pos_of_rect_bottom,
                   swap_buffer_rect_.width(),
@@ skipping 392 matching lines @@
   frame->current_render_pass = NULL;
   frame->current_texture = texture;
 
   return BindFramebufferToTexture(frame, texture, viewport_rect);
 }
 
 void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   output_surface_->BindFramebuffer();
 
-  if (client_->ExternalStencilTestEnabled()) {
+  if (output_surface_->HasExternalStencilTest()) {
     SetStencilEnabled(true);
     GLC(context_, context_->stencilFunc(GL_EQUAL, 1, 1));
   } else {
     SetStencilEnabled(false);
   }
 }
 
 bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
                                           gfx::Rect target_rect) {
@@ skipping 627 matching lines @@
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 void GLRenderer::LazyLabelOffscreenContext(
     ContextProvider* offscreen_context_provider) {
   if (offscreen_context_labelled_)
     return;
   offscreen_context_labelled_ = true;
   std::string unique_context_name = base::StringPrintf(
-      "%s-Offscreen-%p",
-      Settings().compositor_name.c_str(),
-      context_);
-  offscreen_context_provider->Context3d()->pushGroupMarkerEXT(
-      unique_context_name.c_str());
+      "%s-Offscreen-%p", settings_->compositor_name.c_str(), context_);
+  offscreen_context_provider->Context3d()
+      ->pushGroupMarkerEXT(unique_context_name.c_str());
 }
 
 
 }  // namespace cc