| Index: cc/resources/resource_provider.h
|
| diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
|
| deleted file mode 100644
|
| index 9116319758d3b0c1c89ce5f6996fb3fa61e6a539..0000000000000000000000000000000000000000
|
| --- a/cc/resources/resource_provider.h
|
| +++ /dev/null
|
| @@ -1,668 +0,0 @@
|
| -// 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/output/context_provider.h"
|
| -#include "cc/output/output_surface.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_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/geometry/size.h"
|
| -
|
| -class GrContext;
|
| -
|
| -namespace gpu {
|
| -class GpuMemoryBufferManager;
|
| -namespace gles {
|
| -class GLES2Interface;
|
| -}
|
| -}
|
| -
|
| -namespace gfx {
|
| -class GpuMemoryBuffer;
|
| -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 ResourceProvider {
|
| - private:
|
| - struct Resource;
|
| -
|
| - public:
|
| - typedef unsigned ResourceId;
|
| - typedef std::vector<ResourceId> ResourceIdArray;
|
| - typedef std::set<ResourceId> ResourceIdSet;
|
| - typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
|
| - enum TextureHint {
|
| - TEXTURE_HINT_DEFAULT = 0x0,
|
| - TEXTURE_HINT_IMMUTABLE = 0x1,
|
| - TEXTURE_HINT_FRAMEBUFFER = 0x2,
|
| - TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER =
|
| - TEXTURE_HINT_IMMUTABLE | TEXTURE_HINT_FRAMEBUFFER
|
| - };
|
| - enum ResourceType {
|
| - RESOURCE_TYPE_INVALID = 0,
|
| - RESOURCE_TYPE_GL_TEXTURE = 1,
|
| - RESOURCE_TYPE_BITMAP,
|
| - };
|
| -
|
| - static scoped_ptr<ResourceProvider> Create(
|
| - OutputSurface* output_surface,
|
| - SharedBitmapManager* shared_bitmap_manager,
|
| - gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
|
| - BlockingTaskRunner* blocking_main_thread_task_runner,
|
| - int highp_threshold_min,
|
| - bool use_rgba_4444_texture_format,
|
| - size_t id_allocation_chunk_size);
|
| - virtual ~ResourceProvider();
|
| -
|
| - void InitializeSoftware();
|
| - void InitializeGL();
|
| -
|
| - void DidLoseOutputSurface() { lost_output_surface_ = true; }
|
| -
|
| - int max_texture_size() const { return max_texture_size_; }
|
| - ResourceFormat memory_efficient_texture_format() const {
|
| - return use_rgba_4444_texture_format_ ? RGBA_4444 : best_texture_format_;
|
| - }
|
| - ResourceFormat best_texture_format() const { return best_texture_format_; }
|
| - ResourceFormat yuv_resource_format() const { return yuv_resource_format_; }
|
| - bool use_sync_query() const { return use_sync_query_; }
|
| - size_t num_resources() const { return resources_.size(); }
|
| -
|
| - // Checks whether a resource is in use by a consumer.
|
| - bool InUseByConsumer(ResourceId id);
|
| -
|
| - bool IsLost(ResourceId id);
|
| - bool AllowOverlay(ResourceId id);
|
| -
|
| - // Producer interface.
|
| -
|
| - ResourceType default_resource_type() const { return default_resource_type_; }
|
| - ResourceType GetResourceType(ResourceId id);
|
| -
|
| - // Creates a resource of the default resource type.
|
| - ResourceId CreateResource(const gfx::Size& size,
|
| - GLint wrap_mode,
|
| - TextureHint hint,
|
| - ResourceFormat format);
|
| -
|
| - // Creates a resource which is tagged as being managed for GPU memory
|
| - // accounting purposes.
|
| - ResourceId CreateManagedResource(const gfx::Size& size,
|
| - GLenum target,
|
| - GLint wrap_mode,
|
| - TextureHint hint,
|
| - ResourceFormat format);
|
| -
|
| - // You can also explicitly create a specific resource type.
|
| - ResourceId CreateGLTexture(const gfx::Size& size,
|
| - GLenum target,
|
| - GLenum texture_pool,
|
| - GLint wrap_mode,
|
| - TextureHint hint,
|
| - 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<SingleReleaseCallbackImpl> release_callback_impl);
|
| -
|
| - void DeleteResource(ResourceId id);
|
| -
|
| - // Update pixels from image, copying source_rect (in image) to dest_offset (in
|
| - // the resource).
|
| - // NOTE: DEPRECATED. Use CopyToResource() instead.
|
| - void SetPixels(ResourceId id,
|
| - const uint8_t* image,
|
| - const gfx::Rect& image_rect,
|
| - const gfx::Rect& source_rect,
|
| - const gfx::Vector2d& dest_offset);
|
| - void CopyToResource(ResourceId id,
|
| - const uint8_t* image,
|
| - const gfx::Size& image_size);
|
| -
|
| - // Check upload status.
|
| - size_t NumBlockingUploads();
|
| - void MarkPendingUploadsAsNonBlocking();
|
| - size_t EstimatedUploadsPerTick();
|
| - void FlushUploads();
|
| - void ReleaseCachedData();
|
| - base::TimeTicks EstimatedUploadCompletionTime(size_t uploads_per_tick);
|
| -
|
| - // 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
|
| - // mailboxes and serializing meta-data into TransferableResources.
|
| - // Resources are not removed from the ResourceProvider, but are marked as
|
| - // "in use".
|
| - void PrepareSendToParent(const ResourceIdArray& resources,
|
| - TransferableResourceArray* transferable_resources);
|
| -
|
| - // Receives resources from a child, moving them from mailboxes. Resource IDs
|
| - // passed are in the child namespace, and will be translated to the parent
|
| - // namespace, added to the child->parent map.
|
| - // This adds the resources to the working set in the ResourceProvider without
|
| - // declaring which resources are in use. Use DeclareUsedResourcesFromChild
|
| - // after calling this method to do that. All calls to ReceiveFromChild should
|
| - // be followed by a DeclareUsedResourcesFromChild.
|
| - // NOTE: if the sync_point is set on any TransferableResource, this will
|
| - // wait on it.
|
| - void ReceiveFromChild(
|
| - int child, const TransferableResourceArray& transferable_resources);
|
| -
|
| - // Once a set of resources have been received, they may or may not be used.
|
| - // This declares what set of resources are currently in use from the child,
|
| - // releasing any other resources back to the child.
|
| - void DeclareUsedResourcesFromChild(
|
| - int child,
|
| - const ResourceIdArray& resources_from_child);
|
| -
|
| - // Receives resources from the parent, moving them from mailboxes. Resource
|
| - // IDs passed are in the child namespace.
|
| - // NOTE: if the sync_point is set on any TransferableResource, this will
|
| - // wait on it.
|
| - void ReceiveReturnsFromParent(
|
| - const ReturnedResourceArray& transferable_resources);
|
| -
|
| - // The following lock classes are part of the ResourceProvider API and are
|
| - // needed to read and write the resource contents. The user must ensure
|
| - // that they only use GL locks on GL resources, etc, and this is enforced
|
| - // by assertions.
|
| - class ScopedReadLockGL {
|
| - public:
|
| - ScopedReadLockGL(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id);
|
| - virtual ~ScopedReadLockGL();
|
| -
|
| - unsigned texture_id() const { return texture_id_; }
|
| -
|
| - protected:
|
| - ResourceProvider* resource_provider_;
|
| - ResourceProvider::ResourceId resource_id_;
|
| -
|
| - private:
|
| - unsigned texture_id_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL);
|
| - };
|
| -
|
| - class ScopedSamplerGL : public ScopedReadLockGL {
|
| - public:
|
| - ScopedSamplerGL(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id,
|
| - GLenum filter);
|
| - ScopedSamplerGL(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id,
|
| - GLenum unit,
|
| - GLenum filter);
|
| - ~ScopedSamplerGL() override;
|
| -
|
| - GLenum target() const { return target_; }
|
| -
|
| - private:
|
| - GLenum unit_;
|
| - GLenum target_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL);
|
| - };
|
| -
|
| - class ScopedWriteLockGL {
|
| - public:
|
| - ScopedWriteLockGL(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id);
|
| - ~ScopedWriteLockGL();
|
| -
|
| - unsigned texture_id() const { return texture_id_; }
|
| -
|
| - private:
|
| - ResourceProvider* resource_provider_;
|
| - ResourceProvider::Resource* resource_;
|
| - unsigned texture_id_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL);
|
| - };
|
| -
|
| - class ScopedReadLockSoftware {
|
| - public:
|
| - ScopedReadLockSoftware(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id);
|
| - ~ScopedReadLockSoftware();
|
| -
|
| - const SkBitmap* sk_bitmap() const {
|
| - DCHECK(valid());
|
| - return &sk_bitmap_;
|
| - }
|
| - GLint wrap_mode() const { return wrap_mode_; }
|
| -
|
| - bool valid() const { return !!sk_bitmap_.getPixels(); }
|
| -
|
| - private:
|
| - ResourceProvider* resource_provider_;
|
| - ResourceProvider::ResourceId resource_id_;
|
| - SkBitmap sk_bitmap_;
|
| - GLint wrap_mode_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedReadLockSoftware);
|
| - };
|
| -
|
| - class ScopedWriteLockSoftware {
|
| - public:
|
| - ScopedWriteLockSoftware(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id);
|
| - ~ScopedWriteLockSoftware();
|
| -
|
| - SkBitmap& sk_bitmap() { return sk_bitmap_; }
|
| - bool valid() const { return !!sk_bitmap_.getPixels(); }
|
| -
|
| - private:
|
| - ResourceProvider* resource_provider_;
|
| - ResourceProvider::Resource* resource_;
|
| - SkBitmap sk_bitmap_;
|
| - base::ThreadChecker thread_checker_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
|
| - };
|
| -
|
| - class ScopedWriteLockGpuMemoryBuffer {
|
| - public:
|
| - ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id);
|
| - ~ScopedWriteLockGpuMemoryBuffer();
|
| -
|
| - gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
|
| -
|
| - private:
|
| - ResourceProvider* resource_provider_;
|
| - ResourceProvider::Resource* resource_;
|
| - gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
|
| - gfx::GpuMemoryBuffer* gpu_memory_buffer_;
|
| - gfx::Size size_;
|
| - ResourceFormat format_;
|
| - base::ThreadChecker thread_checker_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
|
| - };
|
| -
|
| - class ScopedWriteLockGr {
|
| - public:
|
| - ScopedWriteLockGr(ResourceProvider* resource_provider,
|
| - ResourceProvider::ResourceId resource_id);
|
| - ~ScopedWriteLockGr();
|
| -
|
| - void InitSkSurface(bool use_worker_context,
|
| - bool use_distance_field_text,
|
| - bool can_use_lcd_text,
|
| - int msaa_sample_count);
|
| - void ReleaseSkSurface();
|
| -
|
| - SkSurface* sk_surface() { return sk_surface_.get(); }
|
| - ResourceProvider::Resource* resource() { return resource_; }
|
| -
|
| - private:
|
| - ResourceProvider* resource_provider_;
|
| - ResourceProvider::Resource* resource_;
|
| - base::ThreadChecker thread_checker_;
|
| - skia::RefPtr<SkSurface> sk_surface_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGr);
|
| - };
|
| -
|
| - class Fence : public base::RefCounted<Fence> {
|
| - public:
|
| - Fence() {}
|
| -
|
| - virtual void Set() = 0;
|
| - virtual bool HasPassed() = 0;
|
| - virtual void Wait() = 0;
|
| -
|
| - protected:
|
| - friend class base::RefCounted<Fence>;
|
| - virtual ~Fence() {}
|
| -
|
| - private:
|
| - DISALLOW_COPY_AND_ASSIGN(Fence);
|
| - };
|
| -
|
| - class SynchronousFence : public ResourceProvider::Fence {
|
| - public:
|
| - explicit SynchronousFence(gpu::gles2::GLES2Interface* gl);
|
| -
|
| - // Overridden from Fence:
|
| - void Set() override;
|
| - bool HasPassed() override;
|
| - void Wait() override;
|
| -
|
| - // Returns true if fence has been set but not yet synchornized.
|
| - bool has_synchronized() const { return has_synchronized_; }
|
| -
|
| - private:
|
| - ~SynchronousFence() override;
|
| -
|
| - void Synchronize();
|
| -
|
| - gpu::gles2::GLES2Interface* gl_;
|
| - bool has_synchronized_;
|
| -
|
| - DISALLOW_COPY_AND_ASSIGN(SynchronousFence);
|
| - };
|
| -
|
| - // Acquire pixel buffer for resource. The pixel buffer can be used to
|
| - // set resource pixels without performing unnecessary copying.
|
| - void AcquirePixelBuffer(ResourceId resource);
|
| - void ReleasePixelBuffer(ResourceId resource);
|
| - // Map/unmap the acquired pixel buffer.
|
| - uint8_t* MapPixelBuffer(ResourceId id, int* stride);
|
| - void UnmapPixelBuffer(ResourceId id);
|
| - // Asynchronously update pixels from acquired pixel buffer.
|
| - void BeginSetPixels(ResourceId id);
|
| - void ForceSetPixelsToComplete(ResourceId id);
|
| - bool DidSetPixelsComplete(ResourceId id);
|
| -
|
| - // For tests only! This prevents detecting uninitialized reads.
|
| - // Use SetPixels or LockForWrite to allocate implicitly.
|
| - void AllocateForTesting(ResourceId id);
|
| -
|
| - // For tests only!
|
| - void CreateForTesting(ResourceId id);
|
| -
|
| - GLenum TargetForTesting(ResourceId id);
|
| -
|
| - // Sets the current read fence. If a resource is locked for read
|
| - // and has read fences enabled, the resource will not allow writes
|
| - // until this fence has passed.
|
| - void SetReadLockFence(Fence* fence) { current_read_lock_fence_ = fence; }
|
| -
|
| - // 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);
|
| -
|
| - void WaitReadLockIfNeeded(ResourceId id);
|
| -
|
| - static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
|
| -
|
| - OutputSurface* output_surface() { return output_surface_; }
|
| -
|
| - private:
|
| - struct Resource {
|
| - enum Origin { INTERNAL, EXTERNAL, DELEGATED };
|
| -
|
| - Resource();
|
| - ~Resource();
|
| - Resource(unsigned texture_id,
|
| - const gfx::Size& size,
|
| - Origin origin,
|
| - GLenum target,
|
| - GLenum filter,
|
| - GLenum texture_pool,
|
| - GLint wrap_mode,
|
| - TextureHint hint,
|
| - ResourceFormat format);
|
| - Resource(uint8_t* pixels,
|
| - SharedBitmap* bitmap,
|
| - const gfx::Size& size,
|
| - Origin origin,
|
| - GLenum filter,
|
| - GLint wrap_mode);
|
| - Resource(const SharedBitmapId& bitmap_id,
|
| - const gfx::Size& size,
|
| - Origin origin,
|
| - GLenum filter,
|
| - GLint wrap_mode);
|
| -
|
| - 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;
|
| - 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;
|
| - bool allocated : 1;
|
| - bool read_lock_fences_enabled : 1;
|
| - bool has_shared_bitmap_id : 1;
|
| - bool allow_overlay : 1;
|
| - scoped_refptr<Fence> read_lock_fence;
|
| - gfx::Size size;
|
| - Origin origin;
|
| - GLenum target;
|
| - // TODO(skyostil): Use a separate sampler object for filter state.
|
| - GLenum original_filter;
|
| - GLenum filter;
|
| - unsigned image_id;
|
| - unsigned bound_image_id;
|
| - GLenum texture_pool;
|
| - GLint wrap_mode;
|
| - TextureHint hint;
|
| - ResourceType type;
|
| - ResourceFormat format;
|
| - SharedBitmapId shared_bitmap_id;
|
| - SharedBitmap* shared_bitmap;
|
| - gfx::GpuMemoryBuffer* gpu_memory_buffer;
|
| - };
|
| - typedef base::hash_map<ResourceId, Resource> ResourceMap;
|
| -
|
| - static bool CompareResourceMapIteratorsByChildId(
|
| - const std::pair<ReturnedResource, ResourceMap::iterator>& a,
|
| - const std::pair<ReturnedResource, ResourceMap::iterator>& b);
|
| -
|
| - struct Child {
|
| - Child();
|
| - ~Child();
|
| -
|
| - ResourceIdMap child_to_parent_map;
|
| - ResourceIdMap parent_to_child_map;
|
| - ReturnCallback return_callback;
|
| - ResourceIdSet in_use_resources;
|
| - bool marked_for_deletion;
|
| - };
|
| - 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,
|
| - gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
|
| - BlockingTaskRunner* blocking_main_thread_task_runner,
|
| - int highp_threshold_min,
|
| - bool use_rgba_4444_texture_format,
|
| - size_t id_allocation_chunk_size);
|
| -
|
| - void CleanUpGLIfNeeded();
|
| -
|
| - Resource* GetResource(ResourceId id);
|
| - const Resource* LockForRead(ResourceId id);
|
| - void UnlockForRead(ResourceId id);
|
| - Resource* LockForWrite(ResourceId id);
|
| - void UnlockForWrite(Resource* resource);
|
| -
|
| - static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
|
| - const Resource* resource);
|
| -
|
| - void TransferResource(gpu::gles2::GLES2Interface* gl,
|
| - ResourceId id,
|
| - TransferableResource* resource);
|
| - enum DeleteStyle {
|
| - NORMAL,
|
| - FOR_SHUTDOWN,
|
| - };
|
| - void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
|
| - void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
|
| - DeleteStyle style,
|
| - const ResourceIdArray& unused);
|
| - void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
|
| - void LazyCreate(Resource* resource);
|
| - void LazyAllocate(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(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(bool worker_context) const;
|
| -
|
| - OutputSurface* output_surface_;
|
| - SharedBitmapManager* shared_bitmap_manager_;
|
| - gpu::GpuMemoryBufferManager* gpu_memory_buffer_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_;
|
| - bool use_texture_usage_hint_;
|
| - bool use_compressed_texture_etc1_;
|
| - ResourceFormat yuv_resource_format_;
|
| - scoped_ptr<TextureUploader> texture_uploader_;
|
| - int max_texture_size_;
|
| - ResourceFormat best_texture_format_;
|
| -
|
| - base::ThreadChecker thread_checker_;
|
| -
|
| - scoped_refptr<Fence> current_read_lock_fence_;
|
| - 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_;
|
| - // Fence used for CopyResource if CHROMIUM_sync_query is not supported.
|
| - scoped_refptr<SynchronousFence> synchronous_fence_;
|
| -
|
| - 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) {
|
| - switch (format) {
|
| - case BGRA_8888:
|
| - case RGBA_8888:
|
| - return 32;
|
| - case RGBA_4444:
|
| - case RGB_565:
|
| - return 16;
|
| - case ALPHA_8:
|
| - case LUMINANCE_8:
|
| - case RED_8:
|
| - return 8;
|
| - case ETC1:
|
| - return 4;
|
| - }
|
| - NOTREACHED();
|
| - return 0;
|
| -}
|
| -
|
| -inline GLenum GLDataType(ResourceFormat format) {
|
| - DCHECK_LE(format, RESOURCE_FORMAT_MAX);
|
| - static const unsigned format_gl_data_type[RESOURCE_FORMAT_MAX + 1] = {
|
| - GL_UNSIGNED_BYTE, // RGBA_8888
|
| - GL_UNSIGNED_SHORT_4_4_4_4, // RGBA_4444
|
| - GL_UNSIGNED_BYTE, // BGRA_8888
|
| - GL_UNSIGNED_BYTE, // ALPHA_8
|
| - GL_UNSIGNED_BYTE, // LUMINANCE_8
|
| - GL_UNSIGNED_SHORT_5_6_5, // RGB_565,
|
| - GL_UNSIGNED_BYTE, // ETC1
|
| - GL_UNSIGNED_BYTE // RED_8
|
| - };
|
| - return format_gl_data_type[format];
|
| -}
|
| -
|
| -inline GLenum GLDataFormat(ResourceFormat format) {
|
| - DCHECK_LE(format, RESOURCE_FORMAT_MAX);
|
| - static const unsigned format_gl_data_format[RESOURCE_FORMAT_MAX + 1] = {
|
| - GL_RGBA, // RGBA_8888
|
| - GL_RGBA, // RGBA_4444
|
| - GL_BGRA_EXT, // BGRA_8888
|
| - GL_ALPHA, // ALPHA_8
|
| - GL_LUMINANCE, // LUMINANCE_8
|
| - GL_RGB, // RGB_565
|
| - GL_ETC1_RGB8_OES, // ETC1
|
| - GL_RED_EXT // RED_8
|
| - };
|
| - return format_gl_data_format[format];
|
| -}
|
| -
|
| -inline GLenum GLInternalFormat(ResourceFormat format) {
|
| - return GLDataFormat(format);
|
| -}
|
| -
|
| -} // namespace cc
|
| -
|
| -#endif // CC_RESOURCES_RESOURCE_PROVIDER_H_
|
|
|
Chromium Code Reviews
