Revert of cc::ResourcePool - Re-use larger resources for smaller requests

cc/resources/resource_pool_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 15 matching lines @@
     resource_provider_ = FakeResourceProvider::Create(
         context_provider_.get(), shared_bitmap_manager_.get());
     task_runner_ = base::ThreadTaskRunnerHandle::Get();
     resource_pool_ =
         ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
                              ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                              ResourcePool::kDefaultExpirationDelay);
   }
 
  protected:
-  void CheckAndReturnResource(Resource* resource) {
-    EXPECT_NE(nullptr, resource);
-    resource_pool_->ReleaseResource(resource);
-    resource_pool_->CheckBusyResources();
-  }
-
   scoped_refptr<TestContextProvider> context_provider_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   std::unique_ptr<ResourcePool> resource_pool_;
 };
 
 TEST_F(ResourcePoolTest, AcquireRelease) {
   gfx::Size size(100, 100);
   ResourceFormat format = RGBA_8888;
@@ skipping 52 matching lines @@
   // Limits high enough to not be hit by this test.
   size_t bytes_limit = 10 * 1024 * 1024;
   size_t count_limit = 100;
   resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit);
 
   gfx::Size size(100, 100);
   ResourceFormat format = RGBA_8888;
   gfx::ColorSpace color_space1;
   gfx::ColorSpace color_space2 = gfx::ColorSpace::CreateSRGB();
 
-  CheckAndReturnResource(
-      resource_pool_->AcquireResource(size, format, color_space1));
+  Resource* resource =
+      resource_pool_->AcquireResource(size, format, color_space1);
+  resource_pool_->ReleaseResource(resource);
+  resource_pool_->CheckBusyResources();
   EXPECT_EQ(1u, resource_provider_->num_resources());
 
   // Same size/format should re-use resource.
-  Resource* resource =
-      resource_pool_->AcquireResource(size, format, color_space1);
+  resource = resource_pool_->AcquireResource(size, format, color_space1);
   EXPECT_EQ(1u, resource_provider_->num_resources());
-  CheckAndReturnResource(resource);
+  resource_pool_->ReleaseResource(resource);
+  resource_pool_->CheckBusyResources();
   EXPECT_EQ(1u, resource_provider_->num_resources());
 
   // Different size/format should allocate new resource.
   resource = resource_pool_->AcquireResource(gfx::Size(50, 50), LUMINANCE_8,
                                              color_space1);
   EXPECT_EQ(2u, resource_provider_->num_resources());
-  CheckAndReturnResource(resource);
+  resource_pool_->ReleaseResource(resource);
+  resource_pool_->CheckBusyResources();
   EXPECT_EQ(2u, resource_provider_->num_resources());
 
   // Different color space should allocate new resource.
   resource = resource_pool_->AcquireResource(size, format, color_space2);
   EXPECT_EQ(3u, resource_provider_->num_resources());
-  CheckAndReturnResource(resource);
+  resource_pool_->ReleaseResource(resource);
+  resource_pool_->CheckBusyResources();
   EXPECT_EQ(3u, resource_provider_->num_resources());
 }
 
 TEST_F(ResourcePoolTest, LostResource) {
   // Limits high enough to not be hit by this test.
   size_t bytes_limit = 10 * 1024 * 1024;
   size_t count_limit = 100;
   resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit);
 
   gfx::Size size(100, 100);
@@ skipping 166 matching lines @@
       &total_invalidated_rect);
   EXPECT_EQ(resource, reacquired_resource);
   EXPECT_EQ(expected_total_invalidated_rect, total_invalidated_rect);
   resource_pool_->ReleaseResource(reacquired_resource);
 }
 
 TEST_F(ResourcePoolTest, ReuseResource) {
   ResourceFormat format = RGBA_8888;
   gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB();
 
-  // Create unused resource with size 100x100.
-  CheckAndReturnResource(
-      resource_pool_->CreateResource(gfx::Size(100, 100), format, color_space));
+  // Create unused resources with sizes close to 100, 100.
+  resource_pool_->ReleaseResource(
+      resource_pool_->CreateResource(gfx::Size(99, 100), format, color_space));
+  resource_pool_->ReleaseResource(
+      resource_pool_->CreateResource(gfx::Size(99, 99), format, color_space));
+  resource_pool_->ReleaseResource(
+      resource_pool_->CreateResource(gfx::Size(100, 99), format, color_space));
+  resource_pool_->ReleaseResource(
+      resource_pool_->CreateResource(gfx::Size(101, 101), format, color_space));
+  resource_pool_->CheckBusyResources();
 
-  // Try some cases that are too large, none should succeed.
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(101, 100), format,
-                                                   color_space));
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 101), format,
-                                                   color_space));
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(90, 120), format,
-                                                   color_space));
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(120, 120), format,
-                                                   color_space));
-
-  // Try some cases that are more than 2x smaller than 100x100 in area and
-  // won't be re-used.
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(49, 100), format,
-                                                   color_space));
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 49), format,
-                                                   color_space));
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(50, 50), format,
-                                                   color_space));
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(70, 70), format,
-                                                   color_space));
-
-  // Try some cases that are smaller than 100x100, but within 2x area. Reuse
-  // should succeed.
-  CheckAndReturnResource(
-      resource_pool_->ReuseResource(gfx::Size(50, 100), format, color_space));
-  CheckAndReturnResource(
-      resource_pool_->ReuseResource(gfx::Size(100, 50), format, color_space));
-  CheckAndReturnResource(
-      resource_pool_->ReuseResource(gfx::Size(71, 71), format, color_space));
-
-  // 100x100 is an exact match and should succeed. A subsequent request for
-  // the same size should fail (the resource is already in use).
-  Resource* resource =
-      resource_pool_->ReuseResource(gfx::Size(100, 100), format, color_space);
-  EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 100), format,
-                                                   color_space));
-  CheckAndReturnResource(resource);
+  gfx::Size size(100, 100);
+  Resource* resource = resource_pool_->ReuseResource(size, format, color_space);
+  EXPECT_EQ(nullptr, resource);
+  size = gfx::Size(100, 99);
+  resource = resource_pool_->ReuseResource(size, format, color_space);
+  EXPECT_NE(nullptr, resource);
+  ASSERT_EQ(nullptr, resource_pool_->ReuseResource(size, format, color_space));
+  resource_pool_->ReleaseResource(resource);
 }
 
 TEST_F(ResourcePoolTest, MemoryStateSuspended) {
   // Limits high enough to not be hit by this test.
   size_t bytes_limit = 10 * 1024 * 1024;
   size_t count_limit = 100;
   resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit);
 
   gfx::Size size(100, 100);
   ResourceFormat format = RGBA_8888;
@@ skipping 40 matching lines @@
   resource_pool_ =
       ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
                            ResourceProvider::TEXTURE_HINT_DEFAULT,
                            base::TimeDelta::FromMilliseconds(100));
   resource = resource_pool_->AcquireResource(size, format, color_space);
   EXPECT_FALSE(resource_provider_->IsImmutable(resource->id()));
   resource_pool_->ReleaseResource(resource);
 }
 
 }  // namespace cc