Test multideque

cc/resources/resource_pool.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_pool.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 76 matching lines @@
   DCHECK_EQ(0u, in_use_memory_usage_bytes_);
   DCHECK_EQ(0u, total_memory_usage_bytes_);
   DCHECK_EQ(0u, total_resource_count_);
 }
 
 Resource* ResourcePool::AcquireResource(const gfx::Size& size,
                                         ResourceFormat format) {
   // Finding resources in |unused_resources_| from MRU to LRU direction, touches
   // LRU resources only if needed, which increases possibility of expiring more
   // LRU resources within kResourceExpirationDelayMs.
-  for (ResourceDeque::iterator it = unused_resources_.begin();
-       it != unused_resources_.end(); ++it) {
-    ScopedResource* resource = *it;
-    DCHECK(resource_provider_->CanLockForWrite(resource->id()));
+  {
+    TRACE_EVENT1("cc, pras", "ResourcePool::AcquireResource", "total_unused",
+                 unused_resources_.size());
 
-    if (resource->format() != format)
-      continue;
-    if (resource->size() != size)
-      continue;
+    for (ResourceDeque::iterator it = unused_resources_.begin();
+         it != unused_resources_.end(); ++it) {
+      ScopedResource* resource = *it;
+      DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
-    // Transfer resource to |in_use_resources_|.
-    in_use_resources_.set(resource->id(), unused_resources_.take(it));
-    in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
-        resource->size(), resource->format());
-    return resource;
+      if (resource->format() != format)
+        continue;
+      if (resource->size() != size)
+        continue;
+
+      // Transfer resource to |in_use_resources_|.
+      in_use_resources_.set(resource->id(), unused_resources_.take(it));
+      in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
+          resource->size(), resource->format());
+      return resource;
+    }
   }
 
   scoped_ptr<PoolResource> pool_resource =
       PoolResource::Create(resource_provider_);
   GLenum target =
       target_ ? target_ : resource_provider_->GetImageTextureTarget(format);
   pool_resource->AllocateManaged(size, target, format);
 
   DCHECK(ResourceUtil::VerifySizeInBytes<size_t>(pool_resource->size(),
                                                  pool_resource->format()));
   total_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       pool_resource->size(), pool_resource->format());
   ++total_resource_count_;
 
   Resource* resource = pool_resource.get();
   in_use_resources_.set(resource->id(), pool_resource.Pass());
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
   return resource;
 }
 
 Resource* ResourcePool::TryAcquireResourceWithContentId(uint64_t content_id) {
   DCHECK(content_id);
 
+  TRACE_EVENT_BEGIN1("cc, pras", "ResourcePool::TryAcquireResource",
+                     "total_unused", unused_resources_.size());
+
   auto it = std::find_if(unused_resources_.begin(), unused_resources_.end(),
                          [content_id](const PoolResource* pool_resource) {
                            return pool_resource->content_id() == content_id;
                          });
+
+  TRACE_EVENT_END0("cc, pras", "ResourcePool::TryAcquireResource");
+
   if (it == unused_resources_.end())
     return nullptr;
 
   Resource* resource = *it;
   DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
   // Transfer resource to |in_use_resources_|.
   in_use_resources_.set(resource->id(), unused_resources_.take(it));
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
@@ skipping 67 matching lines @@
     } else if (resource_provider_->IsLost(resource->id())) {
       // Remove lost resources from pool.
       DeleteResource(busy_resources_.take(it));
     } else {
       ++i;
     }
   }
 }
 
 void ResourcePool::DidFinishUsingResource(scoped_ptr<PoolResource> resource) {
+  TRACE_EVENT0("cc, pras", "ResourcePool::DidFinishUsingResource");
   unused_resources_.push_front(resource.Pass());
 }
 
 void ResourcePool::ScheduleEvictExpiredResourcesIn(
     base::TimeDelta time_from_now) {
   if (evict_expired_resources_pending_)
     return;
 
   evict_expired_resources_pending_ = true;
 
@@ skipping 62 matching lines @@
   for (const auto& resource : busy_resources_) {
     resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   for (const auto& entry : in_use_resources_) {
     entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   return true;
 }
 
 }  // namespace cc