cc: Drop ContextProvider references on the impl thread before quitting

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 15 matching lines @@
 #include "cc/output/gl_frame_data.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/render_surface_filters.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/resources/sync_point_helper.h"
+#include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
@@ skipping 73 matching lines @@
   PendingAsyncReadPixels() : buffer(0) {}
 
   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> GLRenderer::Create(
+    RendererClient* client,
+    const LayerTreeSettings* settings,
+    OutputSurface* output_surface,
+    ResourceProvider* resource_provider,
+    TextureMailboxDeleter* texture_mailbox_deleter,
+    int highp_threshold_min,
+    bool use_skia_gpu_backend) {
   scoped_ptr<GLRenderer> renderer(new GLRenderer(client,
                                                  settings,
                                                  output_surface,
                                                  resource_provider,
+                                                 texture_mailbox_deleter,
                                                  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,
+                       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()),
+      texture_mailbox_deleter_(texture_mailbox_deleter),
       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),
@@ skipping 2006 matching lines @@
   pending_async_read_pixels_.insert(pending_async_read_pixels_.begin(),
                                     pending_read.Pass());
 
   // This is a syncronous call since the callback is null.
   gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
   DoGetFramebufferPixels(static_cast<uint8*>(pixels),
                          window_rect,
                          AsyncGetFramebufferPixelsCleanupCallback());
 }
 
-static void DeleteTextureReleaseCallbackOnImplThread(
-    const scoped_refptr<ContextProvider>& context_provider,
-    unsigned texture_id,
-    unsigned sync_point,
-    bool lost_resource) {
-  if (sync_point)
-    context_provider->Context3d()->waitSyncPoint(sync_point);
-  context_provider->Context3d()->deleteTexture(texture_id);
-}
-
-static void DeleteTextureReleaseCallback(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    const scoped_refptr<ContextProvider>& context_provider,
-    unsigned texture_id,
-    unsigned sync_point,
-    bool lost_resource) {
-  task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&DeleteTextureReleaseCallbackOnImplThread,
-                 context_provider,
-                 texture_id,
-                 sync_point,
-                 lost_resource));
-}
-
 void GLRenderer::GetFramebufferPixelsAsync(
     gfx::Rect rect, scoped_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
     return;
 
   DCHECK(gfx::Rect(current_surface_size_).Contains(rect)) <<
       "current_surface_size_: " << current_surface_size_.ToString() <<
@@ skipping 23 matching lines @@
       return;
     }
 
     GLC(context_, context_->bindTexture(GL_TEXTURE_2D, texture_id));
     GLC(context_, context_->produceTextureCHROMIUM(
         GL_TEXTURE_2D, mailbox.name));
     GLC(context_, context_->bindTexture(GL_TEXTURE_2D, 0));
     sync_point = context_->insertSyncPoint();
     scoped_ptr<TextureMailbox> texture_mailbox = make_scoped_ptr(
         new TextureMailbox(mailbox,
-                           base::Bind(&DeleteTextureReleaseCallback,
-                                      base::MessageLoopProxy::current(),
-                                      output_surface_->context_provider(),
-                                      texture_id),
+                           texture_mailbox_deleter_->GetReleaseCallback(
+                               output_surface_->context_provider(), texture_id),
                            GL_TEXTURE_2D,
                            sync_point));
     request->SendTextureResult(window_rect.size(), texture_mailbox.Pass());
     return;
   }
 
   DCHECK(request->force_bitmap_result());
 
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->setConfig(SkBitmap::kARGB_8888_Config,
@@ skipping 893 matching lines @@
     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());
 }
 
 
 }  // namespace cc