Move context-related callbacks into OutputSurface

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 <set>
 #include <string>
 #include <vector>
@@ skipping 101 matching lines @@
       is_scissor_enabled_(false),
       highp_threshold_min_(highp_threshold_min),
       on_demand_tile_raster_resource_id_(0) {
   DCHECK(context_);
 }
 
 bool GLRenderer::Initialize() {
   if (!context_->makeContextCurrent())
     return false;
 
-  context_->setContextLostCallback(this);
   context_->pushGroupMarkerEXT("CompositorContext");
 
   std::string extensions_string =
       UTF16ToASCII(context_->getString(GL_EXTENSIONS));
   std::vector<std::string> extensions_list;
   base::SplitString(extensions_string, ' ', &extensions_list);
   std::set<std::string> extensions(extensions_list.begin(),
                                    extensions_list.end());
 
   if (Settings().accelerate_painting &&
       extensions.count("GL_EXT_texture_format_BGRA8888") &&
       extensions.count("GL_EXT_read_format_bgra"))
     capabilities_.using_accelerated_painting = true;
   else
     capabilities_.using_accelerated_painting = false;
 
   capabilities_.using_partial_swap =
       Settings().partial_swap_enabled &&
       extensions.count("GL_CHROMIUM_post_sub_buffer");
 
   // Use the SwapBuffers callback only with the threaded proxy.
   if (client_->HasImplThread())
     capabilities_.using_swap_complete_callback =
         extensions.count("GL_CHROMIUM_swapbuffers_complete_callback") > 0;
-  if (capabilities_.using_swap_complete_callback)
-    context_->setSwapBuffersCompleteCallbackCHROMIUM(this);
 
   capabilities_.using_set_visibility =
       extensions.count("GL_CHROMIUM_set_visibility") > 0;
 
   if (extensions.count("GL_CHROMIUM_iosurface") > 0)
     DCHECK(extensions.count("GL_ARB_texture_rectangle") > 0);
 
   capabilities_.using_gpu_memory_manager =
       extensions.count("GL_CHROMIUM_gpu_memory_manager") > 0 &&
       Settings().use_memory_management;
@@ skipping 25 matching lines @@
 
   if (!InitializeSharedObjects())
     return false;
 
   // Make sure the viewport and context gets initialized, even if it is to zero.
   ViewportChanged();
   return true;
 }
 
 GLRenderer::~GLRenderer() {
-  context_->setSwapBuffersCompleteCallbackCHROMIUM(NULL);
   context_->setMemoryAllocationChangedCallbackCHROMIUM(NULL);
-  context_->setContextLostCallback(NULL);
   CleanupSharedObjects();
 }
 
 const RendererCapabilities& GLRenderer::Capabilities() const {
   return capabilities_;
 }
 
 WebGraphicsContext3D* GLRenderer::Context() { return context_; }
 
 void GLRenderer::DebugGLCall(WebGraphicsContext3D* context,
@@ skipping 1675 matching lines @@
   // assuming a double-buffered GPU pipeline. A texture can be
   // written to after one full frame has past since it was last read.
   if (last_swap_fence_)
     static_cast<SimpleSwapFence*>(last_swap_fence_.get())->SetHasPassed();
   last_swap_fence_ = resource_provider_->GetReadLockFence();
   resource_provider_->SetReadLockFence(new SimpleSwapFence());
 
   return true;
 }
 
-void GLRenderer::ReceiveCompositorFrameAck(const CompositorFrameAck& ack) {
-  onSwapBuffersComplete();

[jamesr, 2013/04/17 00:15:34]

aha!  This is the change that broke Android.  As it turns out, Android relies on
ReceiveCompositorFrameAck for rate limiting instead of SwapBuffersComplete
callbacks.  I don't fully understand how this works but it's easy enough to
preserve the behavior.

I think the more interesting questions are:
1.) Given that this completely breaks the world on android (the web content
doesn't display at all), should this have been a louder failure on the
trybots/bots?  The failure we did see was so obscure/racy that none of us
thought it was real.

2.) How is Android set up to swap this way and can we have unit tests using this
path so we make sure it works?

I'll look in to (2).  Not sure what to do about (1)

-}
-
-void GLRenderer::onSwapBuffersComplete() { client_->OnSwapBuffersComplete(); }
-
 void GLRenderer::onMemoryAllocationChanged(
     WebGraphicsMemoryAllocation allocation) {
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (allocation.bytesLimitWhenVisible) {
     ManagedMemoryPolicy policy(
         allocation.bytesLimitWhenVisible,
         PriorityCutoff(allocation.priorityCutoffWhenVisible),
         allocation.bytesLimitWhenNotVisible,
@@ skipping 57 matching lines @@
 }
 
 void GLRenderer::EnsureBackbuffer() {
   if (!is_backbuffer_discarded_)
     return;
 
   output_surface_->EnsureBackbuffer();
   is_backbuffer_discarded_ = false;
 }
 
-void GLRenderer::onContextLost() { client_->DidLoseOutputSurface(); }
-
 void GLRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
   DCHECK(rect.right() <= ViewportWidth());
   DCHECK(rect.bottom() <= ViewportHeight());
 
   if (!pixels)
     return;
 
   MakeContextCurrent();
 
   bool do_workaround = NeedsIOSurfaceReadbackWorkaround();
@@ skipping 597 matching lines @@
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc