cc: Use correct message loop proxy in BlockingTaskRunner

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/raster_buffer.h"
-#include "cc/resources/release_callback.h"
+#include "cc/resources/release_callback_impl.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/return_callback.h"
 #include "cc/resources/shared_bitmap.h"
-#include "cc/resources/single_release_callback.h"
+#include "cc/resources/single_release_callback_impl.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/resources/transferable_resource.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/SkCanvas.h"
 #include "ui/gfx/size.h"
 
 class GrContext;
 
 namespace gpu {
 namespace gles {
 class GLES2Interface;
 }
 }
 
 namespace gfx {
 class Rect;
 class Vector2d;
 }
 
 namespace cc {
+class BlockingTaskRunner;
 class IdAllocator;
 class SharedBitmap;
 class SharedBitmapManager;
 class TextureUploader;
 
 // This class is not thread-safe and can only be called from the thread it was
 // created on (in practice, the impl thread).
 class CC_EXPORT ResourceProvider {
  public:
   typedef unsigned ResourceId;
   typedef std::vector<ResourceId> ResourceIdArray;
   typedef std::set<ResourceId> ResourceIdSet;
   typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
   enum TextureHint {
     TextureHintDefault = 0x0,
     TextureHintImmutable = 0x1,
     TextureHintFramebuffer = 0x2,
     TextureHintImmutableFramebuffer =
         TextureHintImmutable | TextureHintFramebuffer
   };
   enum ResourceType {
     InvalidType = 0,
     GLTexture = 1,
     Bitmap,
   };
 
   static scoped_ptr<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);
   virtual ~ResourceProvider();
 
   void InitializeSoftware();
   void InitializeGL();
 
   void DidLoseOutputSurface() { lost_output_surface_ = true; }
@@ skipping 40 matching lines @@
                              ResourceFormat format);
 
   ResourceId CreateBitmap(const gfx::Size& size, GLint wrap_mode);
   // Wraps an IOSurface into a GL resource.
   ResourceId CreateResourceFromIOSurface(const gfx::Size& size,
                                          unsigned io_surface_id);
 
   // Wraps an external texture mailbox into a GL resource.
   ResourceId CreateResourceFromTextureMailbox(
       const TextureMailbox& mailbox,
-      scoped_ptr<SingleReleaseCallback> release_callback);
+      scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl);
 
   void DeleteResource(ResourceId id);
 
   // Update pixels from image, copying source_rect (in image) to dest_offset (in
   // the resource).
   void SetPixels(ResourceId id,
                  const uint8_t* image,
                  const gfx::Rect& image_rect,
                  const gfx::Rect& source_rect,
                  const gfx::Vector2d& dest_offset);
@@ skipping 214 matching lines @@
   // Indicates if we can currently lock this resource for write.
   bool CanLockForWrite(ResourceId id);
 
   // Copy pixels from source to destination.
   void CopyResource(ResourceId source_id, ResourceId dest_id);
 
   void WaitSyncPointIfNeeded(ResourceId id);
 
   static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
 
+  BlockingTaskRunner* blocking_main_thread_task_runner() const {

[danakj, 2014/09/03 16:09:36]

remove this

[Sami, 2014/09/03 17:59:12]

Done.

+    return blocking_main_thread_task_runner_;
+  }
+
  private:
   class GpuRasterBuffer;
   class ImageRasterBuffer;
   class PixelRasterBuffer;
 
   struct Resource {
     enum Origin { Internal, External, Delegated };
 
     Resource();
     ~Resource();
@@ skipping 20 matching lines @@
 
     int child_id;
     unsigned gl_id;
     // Pixel buffer used for set pixels without unnecessary copying.
     unsigned gl_pixel_buffer_id;
     // Query used to determine when asynchronous set pixels complete.
     unsigned gl_upload_query_id;
     // Query used to determine when read lock fence has passed.
     unsigned gl_read_lock_query_id;
     TextureMailbox mailbox;
-    ReleaseCallback release_callback;
+    ReleaseCallbackImpl release_callback_impl;
     uint8_t* pixels;
     int lock_for_read_count;
     int imported_count;
     int exported_count;
     bool dirty_image : 1;
     bool locked_for_write : 1;
     bool lost : 1;
     bool marked_for_deletion : 1;
     bool pending_set_pixels : 1;
     bool set_pixels_completion_forced : 1;
@@ skipping 103 matching lines @@
   };
   typedef base::hash_map<int, Child> ChildMap;
 
   bool ReadLockFenceHasPassed(const Resource* resource) {
     return !resource->read_lock_fence.get() ||
            resource->read_lock_fence->HasPassed();
   }
 
   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);
 
   void CleanUpGLIfNeeded();
 
   Resource* GetResource(ResourceId id);
   const Resource* LockForRead(ResourceId id);
   void UnlockForRead(ResourceId id);
@@ skipping 43 matching lines @@
   GLenum BindForSampling(ResourceProvider::ResourceId resource_id,
                          GLenum unit,
                          GLenum filter);
 
   // Returns NULL if the output_surface_ does not have a ContextProvider.
   gpu::gles2::GLES2Interface* ContextGL() const;
   class GrContext* GrContext() const;
 
   OutputSurface* output_surface_;
   SharedBitmapManager* shared_bitmap_manager_;
+  BlockingTaskRunner* blocking_main_thread_task_runner_;
   bool lost_output_surface_;
   int highp_threshold_min_;
   ResourceId next_id_;
   ResourceMap resources_;
   int next_child_;
   ChildMap children_;
 
   ResourceType default_resource_type_;
   bool use_texture_storage_ext_;
   bool use_texture_format_bgra_;
@@ skipping 64 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_