cc: Delete the Renderer base class.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 284 matching lines @@
 
   gpu::gles2::GLES2Interface* gl_;
   unsigned query_id_;
   bool is_pending_;
   base::WeakPtrFactory<SyncQuery> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncQuery);
 };
 
 std::unique_ptr<GLRenderer> GLRenderer::Create(
-    RendererClient* client,
+    DirectRendererClient* client,
     const RendererSettings* settings,
     OutputSurface* output_surface,
     ResourceProvider* resource_provider,
     TextureMailboxDeleter* texture_mailbox_deleter,
     int highp_threshold_min) {
   return base::WrapUnique(
       new GLRenderer(client, settings, output_surface, resource_provider,
                      texture_mailbox_deleter, highp_threshold_min));
 }
 
-GLRenderer::GLRenderer(RendererClient* client,
+GLRenderer::GLRenderer(DirectRendererClient* client,
                        const RendererSettings* settings,
                        OutputSurface* output_surface,
                        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_(QuadVertexRect()),
       gl_(output_surface->context_provider()->ContextGL()),
       context_support_(output_surface->context_provider()->ContextSupport()),
       texture_mailbox_deleter_(texture_mailbox_deleter),
-      is_backbuffer_discarded_(false),
       is_scissor_enabled_(false),
       scissor_rect_needs_reset_(true),
       stencil_shadow_(false),
       blend_shadow_(false),
       highp_threshold_min_(highp_threshold_min),
       highp_threshold_cache_(0),
       use_sync_query_(false),
       bound_geometry_(NO_BINDING) {
   DCHECK(gl_);
   DCHECK(context_support_);
@@ skipping 45 matching lines @@
     pending_async_read_pixels_.pop_back();
   }
 
   CleanupSharedObjects();
 }
 
 const RendererCapabilitiesImpl& GLRenderer::Capabilities() const {
   return capabilities_;
 }
 
-void GLRenderer::DidChangeVisibility() {
-  EnforceMemoryPolicy();
-
-  // If we are not visible, we ask the context to aggressively free resources.
-  context_support_->SetAggressivelyFreeResources(!visible());
-}
-
 void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }
 
 void GLRenderer::DiscardPixels() {
   if (!capabilities_.using_discard_framebuffer)
     return;
   bool using_default_framebuffer =
       !current_framebuffer_lock_ &&
       output_surface_->capabilities().uses_default_gl_framebuffer;
   GLenum attachments[] = {static_cast<GLenum>(
       using_default_framebuffer ? GL_COLOR_EXT : GL_COLOR_ATTACHMENT0_EXT)};
@@ skipping 2296 matching lines @@
   PrepareGeometry(SHARED_BINDING);
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
   gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
-void GLRenderer::Finish() {
-  TRACE_EVENT0("cc", "GLRenderer::Finish");
-  gl_->Finish();
-}
-
 void GLRenderer::SwapBuffers(CompositorFrameMetadata metadata) {
-  DCHECK(!is_backbuffer_discarded_);
-
   TRACE_EVENT0("cc,benchmark", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
   gfx::Size surface_size = output_surface_->SurfaceSize();
 
   CompositorFrame compositor_frame;
   compositor_frame.metadata = std::move(metadata);
   compositor_frame.gl_frame_data = base::WrapUnique(new GLFrameData);
   compositor_frame.gl_frame_data->size = surface_size;
   if (capabilities_.using_partial_swap) {
@@ skipping 68 matching lines @@
 void GLRenderer::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   DCHECK(settings_->release_overlay_resources_after_gpu_query);
   for (const gpu::TextureInUseResponse& response : responses) {
     if (!response.in_use) {
       swapped_and_acked_overlay_resources_.erase(response.texture);
     }
   }
 }
 
-void GLRenderer::EnforceMemoryPolicy() {
-  if (!visible()) {
-    TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
-    ReleaseRenderPassTextures();
-    DiscardBackbuffer();
-    output_surface_->context_provider()->DeleteCachedResources();
-    gl_->Flush();
-  }
-  PrepareGeometry(NO_BINDING);
-}
-
-void GLRenderer::DiscardBackbuffer() {
-  if (is_backbuffer_discarded_)
-    return;
-
-  output_surface_->DiscardBackbuffer();
-
-  is_backbuffer_discarded_ = true;
-
-  // Damage tracker needs a full reset every time framebuffer is discarded.
-  client_->SetFullRootLayerDamage();
-}
-
-void GLRenderer::EnsureBackbuffer() {
-  if (!is_backbuffer_discarded_)
-    return;
-
-  output_surface_->EnsureBackbuffer();
-  is_backbuffer_discarded_ = false;
-}
-
 void GLRenderer::GetFramebufferPixelsAsync(
     const DrawingFrame* frame,
     const gfx::Rect& rect,
     std::unique_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
     return;
 
@@ skipping 89 matching lines @@
   base::Closure cancelable_callback =
       pending_async_read_pixels_.front()->
           finished_read_pixels_callback.callback();
 
   // Save the buffer to verify the callbacks happen in the expected order.
   pending_async_read_pixels_.front()->buffer = buffer;
 
   gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
   context_support_->SignalQuery(query, cancelable_callback);
 
-  EnforceMemoryPolicy();
+  // WHY???

[enne (OOO), 2016/08/08 21:41:18]

This doesn't seem needed to me, but feel free to remove it in another patch if
you want to mitigate risk with this patch.

+  PrepareGeometry(NO_BINDING);
 }
 
 void GLRenderer::FinishedReadback(unsigned source_buffer,
                                   unsigned query,
                                   const gfx::Size& size) {
   DCHECK(!pending_async_read_pixels_.empty());
 
   if (query != 0) {
     gl_->DeleteQueriesEXT(1, &query);
   }
@@ skipping 813 matching lines @@
         resource_provider_, contents_texture->id()));
     source_texture = source->texture_id();
   }
   gl_->CopySubTextureCHROMIUM(source_texture, destination.texture_id(), 0, 0, 0,
                               0, contents_texture->size().width(),
                               contents_texture->size().height(), GL_TRUE,
                               GL_FALSE, GL_FALSE);
 }
 
 }  // namespace cc