Move context-related callbacks into OutputSurface

cc/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/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 92 matching lines @@
       is_using_bind_uniform_(false),
       visible_(true),
       is_scissor_enabled_(false) {
   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().acceleratePainting &&
       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().partialSwapEnabled &&
       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");
-  if (capabilities_.using_swap_complete_callback)
-    context_->setSwapBuffersCompleteCallbackCHROMIUM(this);
 
   capabilities_.using_set_visibility =
       extensions.count("GL_CHROMIUM_set_visibility");
 
   if (extensions.count("GL_CHROMIUM_iosurface"))
     DCHECK(extensions.count("GL_ARB_texture_rectangle"));
 
   capabilities_.using_gpu_memory_manager =
       extensions.count("GL_CHROMIUM_gpu_memory_manager") &&
       Settings().useMemoryManagement;
@@ skipping 24 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 1405 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();
-}
-
-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 422 matching lines @@
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc