cc: Refactor ResourceProvider.

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/release_callback.h"
 #include "cc/resources/resource_format.h"
+#include "cc/resources/resource_helper.h"
 #include "cc/resources/return_callback.h"
 #include "cc/resources/shared_bitmap.h"
 #include "cc/resources/single_release_callback.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"
@@ skipping 111 matching lines @@
                  const gfx::Vector2d& dest_offset);
 
   // Check upload status.
   size_t NumBlockingUploads();
   void MarkPendingUploadsAsNonBlocking();
   size_t EstimatedUploadsPerTick();
   void FlushUploads();
   void ReleaseCachedData();
   base::TimeTicks EstimatedUploadCompletionTime(size_t uploads_per_tick);
 
-  // Flush all context operations, kicking uploads and ensuring ordering with
-  // respect to other contexts.
-  void Flush();
-
-  // Finish all context operations, causing any pending callbacks to be
-  // scheduled.
-  void Finish();
-
-  // Only flush the command buffer if supported.
-  // Returns true if the shallow flush occurred, false otherwise.
-  bool ShallowFlushIfSupported();
-
   // Creates accounting for a child. Returns a child ID.
   int CreateChild(const ReturnCallback& return_callback);
 
   // Destroys accounting for the child, deleting all accounted resources.
   void DestroyChild(int child);
 
   // Gets the child->parent resource ID map.
   const ResourceIdMap& GetChildToParentMap(int child) const;
 
   // Prepares resources to be transfered to the parent, moving them to
@@ skipping 121 matching lines @@
 
    private:
     ResourceProvider* resource_provider_;
     ResourceProvider::ResourceId resource_id_;
     SkBitmap sk_bitmap_;
     scoped_ptr<SkCanvas> sk_canvas_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
   };
 
-  // The following class is needed to modify GL resources using GPU
-  // raster. The user must ensure that they only use GPU raster on
-  // GL resources while an instance of this class is alive.
-  class CC_EXPORT ScopedGpuRaster {
-   public:
-    ScopedGpuRaster(ResourceProvider* resource_provider);
-    ~ScopedGpuRaster();
-
-   private:
-    ResourceProvider* resource_provider_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedGpuRaster);
-  };
-
   class Fence : public base::RefCounted<Fence> {
    public:
     Fence() {}
     virtual bool HasPassed() = 0;
 
    protected:
     friend class base::RefCounted<Fence>;
     virtual ~Fence() {}
 
    private:
@@ skipping 46 matching lines @@
 
   // Enable read lock fences for a specific resource.
   void EnableReadLockFences(ResourceProvider::ResourceId id, bool enable);
 
   // 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);
 
-  static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
+  ResourceHelper* GetResourceHelper() { return resource_helper_.get(); }
 
  private:
   class GpuRasterBuffer;
   class ImageRasterBuffer;
   class PixelRasterBuffer;
 
   struct Resource {
     enum Origin { Internal, External, Delegated };
 
     Resource();
@@ skipping 230 matching lines @@
   void UnmapImage(const Resource* resource);
 
   void BindImageForSampling(Resource* resource);
   // Binds the given GL resource to a texture target for sampling using the
   // specified filter for both minification and magnification. Returns the
   // texture target used. The resource must be locked for reading.
   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;

[danakj, 2014/07/09 16:01:33]

These are private methods used internally in ResourceProvider, let's leave them.

[sohanjg, 2014/07/10 15:11:06]

Done.

Had to pull them to public though, because ScopedGpuRaster would need them, and
we had pulled that class out of ResourceProvider.

-  class GrContext* GrContext() const;
-
-  void BeginGpuRaster();
-  void EndGpuRaster();
-
   OutputSurface* output_surface_;
   SharedBitmapManager* shared_bitmap_manager_;
   bool lost_output_surface_;
   int highp_threshold_min_;
   ResourceId next_id_;
   ResourceMap resources_;
   int next_child_;
   ChildMap children_;
 
   ResourceType default_resource_type_;
@@ skipping 10 matching lines @@
   bool use_rgba_4444_texture_format_;
 
   const size_t id_allocation_chunk_size_;
   scoped_ptr<IdAllocator> texture_id_allocator_;
   scoped_ptr<IdAllocator> buffer_id_allocator_;
 
   bool use_sync_query_;
 
   bool use_distance_field_text_;
 
+  scoped_ptr<ResourceHelper> resource_helper_;
+
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 
 // TODO(epenner): Move these format conversions to resource_format.h
 // once that builds on mac (npapi.h currently #includes OpenGL.h).
 inline unsigned BitsPerPixel(ResourceFormat format) {
   DCHECK_LE(format, RESOURCE_FORMAT_MAX);
   static const unsigned format_bits_per_pixel[RESOURCE_FORMAT_MAX + 1] = {
     32,  // RGBA_8888
@@ skipping 32 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_