cc: Keep track of busy resources in ResourcePool

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/scoped_ptr.h"
+#include "base/memory/weak_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/return_callback.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"
 
 namespace WebKit { class WebGraphicsContext3D; }
 
 namespace gfx {
 class Rect;
 class Vector2d;
 }
 
 namespace cc {
 class SharedBitmap;
 class SharedBitmapManager;
 class TextureUploader;
+class ResourceProviderClient;
 
 // 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 {
+class CC_EXPORT ResourceProvider
+    : public base::SupportsWeakPtr<ResourceProvider> {

[piman, 2013/10/25 21:51:11]

we want to remove the use of SupportsWeakPtr in the codebase, because it's
fundamentally unsafe. Instead, add a WeakPtrFactory as the last field. However,
see my comments in resource_pool.cc, I don't think you need weak ptrs (and I'd
rather we didn't).

  public:
   typedef unsigned ResourceId;
   typedef std::vector<ResourceId> ResourceIdArray;
   typedef std::set<ResourceId> ResourceIdSet;
   typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
   enum TextureUsageHint {
     TextureUsageAny,
     TextureUsageFramebuffer,
   };
   enum ResourceType {
     InvalidType = 0,
     GLTexture = 1,
     Bitmap,
   };
 
   static scoped_ptr<ResourceProvider> Create(
       OutputSurface* output_surface,
       SharedBitmapManager* shared_bitmap_manager,
       int highp_threshold_min,
       bool use_rgba_4444_texture_format);
   virtual ~ResourceProvider();
 
+  void SetClient(ResourceProviderClient* client);
+
   void InitializeSoftware();
   bool 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_; }
   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 IsExported(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(gfx::Size size,
                             GLint wrap_mode,
                             TextureUsageHint hint,
@@ skipping 365 matching lines @@
   // specified filter for both minification and magnification. The resource
   // must be locked for reading.
   void BindForSampling(ResourceProvider::ResourceId resource_id,
                        GLenum target,
                        GLenum unit,
                        GLenum filter);
 
   // Returns NULL if the output_surface_ does not have a ContextProvider.
   WebKit::WebGraphicsContext3D* Context3d() const;
 
+  ResourceProviderClient* client_;
   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_;
   bool use_texture_storage_ext_;
   bool use_texture_usage_hint_;
   bool use_shallow_flush_;
   bool use_compressed_texture_etc1_;
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
+class ResourceProviderClient {
+ public:
+  virtual void ResourceExported(ResourceProvider::ResourceId id) = 0;
+  virtual void ResourceReturned(ResourceProvider::ResourceId id) = 0;
+};
 
 // 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
     16,  // RGBA_4444
     32,  // BGRA_8888
     8,   // LUMINANCE_8
@@ skipping 29 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_