cc: Use correct message loop proxy in BlockingTaskRunner

cc/resources/resource_provider.cc

 // Copyright 2012 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/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 583 matching lines @@
   raster_bitmap_.reset();
 }
 
 ResourceProvider::Child::Child() : marked_for_deletion(false) {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
+    BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
     bool use_distance_field_text) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface,
                            shared_bitmap_manager,
+                           blocking_main_thread_task_runner,
                            highp_threshold_min,
                            use_rgba_4444_texture_format,
                            id_allocation_chunk_size,
                            use_distance_field_text));
 
   if (resource_provider->ContextGL())
     resource_provider->InitializeGL();
   else
     resource_provider->InitializeSoftware();
 
@@ skipping 149 matching lines @@
   gl->BindTexture(GL_TEXTURE_RECTANGLE_ARB, resource.gl_id);
   gl->TexImageIOSurface2DCHROMIUM(
       GL_TEXTURE_RECTANGLE_ARB, size.width(), size.height(), io_surface_id, 0);
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallback> release_callback) {
+    scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource& resource = resources_[id];
   if (mailbox.IsTexture()) {
     resource = Resource(0,
                         gfx::Size(),
                         Resource::External,
                         mailbox.target(),
@@ skipping 15 matching lines @@
     }
     resource = Resource(pixels,
                         shared_bitmap.release(),
                         mailbox.shared_memory_size(),
                         Resource::External,
                         GL_LINEAR,
                         GL_CLAMP_TO_EDGE);
   }
   resource.allocated = true;
   resource.mailbox = mailbox;
-  resource.release_callback =
-      base::Bind(&SingleReleaseCallback::Run,
-                 base::Owned(release_callback.release()));
+  resource.release_callback_impl =
+      base::Bind(&SingleReleaseCallbackImpl::Run,
+                 base::Owned(release_callback_impl.release()));
   resource.allow_overlay = mailbox.allow_overlay();
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->marked_for_deletion);
@@ skipping 63 matching lines @@
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       base::SharedMemory* shared_memory = resource->mailbox.shared_memory();
       if (resource->pixels && shared_memory) {
         DCHECK(shared_memory->memory() == resource->pixels);
         resource->pixels = NULL;
         delete resource->shared_bitmap;
         resource->shared_bitmap = NULL;
       }
     }
-    resource->release_callback.Run(sync_point, lost_resource);
+    resource->release_callback_impl.Run(
+        sync_point, lost_resource, blocking_main_thread_task_runner_);
   }
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
     resource->gl_id = 0;
   }
   if (resource->shared_bitmap) {
     DCHECK(resource->origin != Resource::External);
     DCHECK_EQ(Bitmap, resource->type);
@@ skipping 306 matching lines @@
   ResourceProvider::PopulateSkBitmapWithResource(
       &sk_bitmap_, resource_provider->LockForWrite(resource_id));
   DCHECK(valid());
   sk_canvas_.reset(new SkCanvas(sk_bitmap_));
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   resource_provider_->UnlockForWrite(resource_id_);
 }
 
-ResourceProvider::ResourceProvider(OutputSurface* output_surface,
-                                   SharedBitmapManager* shared_bitmap_manager,
-                                   int highp_threshold_min,
-                                   bool use_rgba_4444_texture_format,
-                                   size_t id_allocation_chunk_size,
-                                   bool use_distance_field_text)
+ResourceProvider::ResourceProvider(
+    OutputSurface* output_surface,
+    SharedBitmapManager* shared_bitmap_manager,
+    BlockingTaskRunner* blocking_main_thread_task_runner,
+    int highp_threshold_min,
+    bool use_rgba_4444_texture_format,
+    size_t id_allocation_chunk_size,
+    bool use_distance_field_text)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
+      blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_format_bgra_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
       max_texture_size_(0),
@@ skipping 167 matching lines @@
       resource.marked_for_deletion = false;
       resource.imported_count++;
       continue;
     }
 
     if ((!it->is_software && !gl) ||
         (it->is_software && !shared_bitmap_manager_)) {
       TRACE_EVENT0("cc", "ResourceProvider::ReceiveFromChild dropping invalid");
       ReturnedResourceArray to_return;
       to_return.push_back(it->ToReturnedResource());
-      child_info.return_callback.Run(to_return);
+      child_info.return_callback.Run(to_return,
+                                     blocking_main_thread_task_runner_);
       continue;
     }
 
     ResourceId local_id = next_id_++;
     Resource& resource = resources_[local_id];
     if (it->is_software) {
       resource = Resource(it->mailbox_holder.mailbox,
                           it->size,
                           Resource::Delegated,
                           GL_LINEAR,
@@ skipping 294 matching lines @@
   if (need_sync_point) {
     DCHECK(gl);
     GLuint sync_point = gl->InsertSyncPointCHROMIUM();
     for (size_t i = 0; i < to_return.size(); ++i) {
       if (!to_return[i].sync_point)
         to_return[i].sync_point = sync_point;
     }
   }
 
   if (!to_return.empty())
-    child_info->return_callback.Run(to_return);
+    child_info->return_callback.Run(to_return,
+                                    blocking_main_thread_task_runner_);
 
   if (child_info->marked_for_deletion &&
       child_info->parent_to_child_map.empty()) {
     DCHECK(child_info->child_to_parent_map.empty());
     children_.erase(child_it);
   }
 }
 
 RasterBuffer* ResourceProvider::AcquireGpuRasterBuffer(ResourceId id) {
   // Resource needs to be locked for write since GpuRasterBuffer writes
@@ skipping 544 matching lines @@
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc