cc: Keep track of busy resources in ResourcePool

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 240 matching lines @@
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0 ||
          resource->lost;
 }
 
 bool ResourceProvider::IsLost(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lost;
 }
 
+bool ResourceProvider::IsExported(ResourceId id) {
+  Resource* resource = GetResource(id);
+  return resource->exported_count > 0;
+}
+
 ResourceProvider::ResourceId ResourceProvider::CreateResource(
     gfx::Size size,
     GLint wrap_mode,
     TextureUsageHint hint,
     ResourceFormat format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
       return CreateGLTexture(
           size, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM, wrap_mode, hint, format);
@@ skipping 514 matching lines @@
 }
 
 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)
-    : output_surface_(output_surface),
+    : client_(NULL),
+      output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
       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_usage_hint_(false),
       use_shallow_flush_(false),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format) {
   DCHECK(output_surface_->HasClient());
 }
 
+void ResourceProvider::SetClient(ResourceProviderClient* client) {
+  client_ = client;
+}
+
 void ResourceProvider::InitializeSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(Bitmap, default_resource_type_);
 
   CleanUpGLIfNeeded();
 
   default_resource_type_ = Bitmap;
   max_texture_size_ = INT_MAX / 2;
   best_texture_format_ = RGBA_8888;
 }
@@ skipping 96 matching lines @@
   if (context3d)
     context3d->makeContextCurrent();
   bool need_sync_point = false;
   for (ResourceIdArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     TransferableResource resource;
     TransferResource(context3d, *it, &resource);
     if (!resource.sync_point && !resource.is_software)
       need_sync_point = true;
-    ++resources_.find(*it)->second.exported_count;
+    ResourceMap::iterator resource_it = resources_.find(*it);
+    if (resource_it->second.exported_count == 0) {
+      if (client_)
+        client_->ResourceExported(*it);
+    }
+    ++resource_it->second.exported_count;
     list->push_back(resource);
   }
   if (need_sync_point) {
     unsigned int sync_point = context3d->insertSyncPoint();
     for (TransferableResourceArray::iterator it = list->begin();
          it != list->end();
          ++it) {
       if (!it->sync_point)
         it->sync_point = sync_point;
     }
@@ skipping 147 matching lines @@
             CompareResourceMapIteratorsByChildId);
 
   for (size_t i = 0; i < sorted_resources.size(); ++i) {
     ReturnedResource& returned = sorted_resources[i].first;
     ResourceMap::iterator& map_iterator = sorted_resources[i].second;
     ResourceId local_id = map_iterator->first;
     Resource* resource = &map_iterator->second;
 
     CHECK_GE(resource->exported_count, returned.count);
     resource->exported_count -= returned.count;
+    if (resource->exported_count == 0) {
+      if (client_)
+        client_->ResourceReturned(local_id);
+    }
     resource->lost |= returned.lost;
     if (resource->exported_count)
       continue;
 
     if (resource->gl_id) {
       if (returned.sync_point)
         GLC(context3d, context3d->waitSyncPoint(returned.sync_point));
     } else if (!resource->shared_bitmap) {
       resource->mailbox =
           TextureMailbox(resource->mailbox.name(), returned.sync_point);
@@ skipping 618 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 WebKit::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc