cc/resources/resource_pool_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/resource_pool.h"
   6
   7 #include "cc/resources/resource_util.h"
   8 #include "cc/resources/scoped_resource.h"
   9 #include "cc/test/fake_output_surface.h"
  10 #include "cc/test/fake_output_surface_client.h"
  11 #include "cc/test/fake_resource_provider.h"
  12 #include "cc/test/test_shared_bitmap_manager.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace cc {
  16 namespace {
  17
  18 class ResourcePoolTest : public testing::Test {
  19  public:
  20   void SetUp() override {
  21     output_surface_ = FakeOutputSurface::Create3d();
  22     ASSERT_TRUE(output_surface_->BindToClient(&output_surface_client_));
  23     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
  24     resource_provider_ = FakeResourceProvider::Create(
  25         output_surface_.get(), shared_bitmap_manager_.get());
  26     resource_pool_ =
  27         ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
  28   }
  29
  30  protected:
  31   FakeOutputSurfaceClient output_surface_client_;
  32   scoped_ptr<FakeOutputSurface> output_surface_;
  33   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
  34   scoped_ptr<ResourceProvider> resource_provider_;
  35   scoped_ptr<ResourcePool> resource_pool_;
  36 };
  37
  38 TEST_F(ResourcePoolTest, AcquireRelease) {
  39   gfx::Size size(100, 100);
  40   ResourceFormat format = RGBA_8888;
  41   Resource* resource = resource_pool_->AcquireResource(size, format);
  42   EXPECT_EQ(size, resource->size());
  43   EXPECT_EQ(format, resource->format());
  44   EXPECT_TRUE(resource_provider_->CanLockForWrite(resource->id()));
  45
  46   resource_pool_->ReleaseResource(resource, 0u);
  47 }
  48
  49 TEST_F(ResourcePoolTest, AccountingSingleResource) {
  50   // Limits high enough to not be hit by this test.
  51   size_t bytes_limit = 10 * 1024 * 1024;
  52   size_t count_limit = 100;
  53   resource_pool_->SetResourceUsageLimits(bytes_limit, bytes_limit, count_limit);
  54
  55   gfx::Size size(100, 100);
  56   ResourceFormat format = RGBA_8888;
  57   size_t resource_bytes =
  58       ResourceUtil::UncheckedSizeInBytes<size_t>(size, format);
  59   Resource* resource = resource_pool_->AcquireResource(size, format);
  60
  61   EXPECT_EQ(resource_bytes, resource_pool_->total_memory_usage_bytes());
  62   EXPECT_EQ(resource_bytes, resource_pool_->acquired_memory_usage_bytes());
  63   EXPECT_EQ(1u, resource_pool_->total_resource_count());
  64   EXPECT_EQ(1u, resource_pool_->acquired_resource_count());
  65   EXPECT_EQ(0u, resource_pool_->busy_resource_count());
  66
  67   resource_pool_->ReleaseResource(resource, 0u);
  68   EXPECT_EQ(resource_bytes, resource_pool_->total_memory_usage_bytes());
  69   EXPECT_EQ(1u, resource_pool_->total_resource_count());
  70   EXPECT_EQ(1u, resource_pool_->busy_resource_count());
  71
  72   resource_pool_->CheckBusyResources();
  73   EXPECT_EQ(resource_bytes, resource_pool_->total_memory_usage_bytes());
  74   EXPECT_EQ(0u, resource_pool_->acquired_memory_usage_bytes());
  75   EXPECT_EQ(1u, resource_pool_->total_resource_count());
  76   EXPECT_EQ(0u, resource_pool_->acquired_resource_count());
  77   EXPECT_EQ(0u, resource_pool_->busy_resource_count());
  78
  79   resource_pool_->SetResourceUsageLimits(0u, 0u, 0u);
  80   resource_pool_->ReduceResourceUsage();
  81   EXPECT_EQ(0u, resource_pool_->total_memory_usage_bytes());
  82   EXPECT_EQ(0u, resource_pool_->acquired_memory_usage_bytes());
  83   EXPECT_EQ(0u, resource_pool_->total_resource_count());
  84   EXPECT_EQ(0u, resource_pool_->acquired_resource_count());
  85   EXPECT_EQ(0u, resource_pool_->busy_resource_count());
  86 }
  87
  88 TEST_F(ResourcePoolTest, SimpleResourceReuse) {
  89   // Limits high enough to not be hit by this test.
  90   size_t bytes_limit = 10 * 1024 * 1024;
  91   size_t count_limit = 100;
  92   resource_pool_->SetResourceUsageLimits(bytes_limit, bytes_limit, count_limit);
  93
  94   gfx::Size size(100, 100);
  95   ResourceFormat format = RGBA_8888;
  96
  97   Resource* resource = resource_pool_->AcquireResource(size, format);
  98   resource_pool_->ReleaseResource(resource, 0u);
  99   resource_pool_->CheckBusyResources();
 100   EXPECT_EQ(1u, resource_provider_->num_resources());
 101
 102   // Same size/format should re-use resource.
 103   resource = resource_pool_->AcquireResource(size, format);
 104   EXPECT_EQ(1u, resource_provider_->num_resources());
 105   resource_pool_->ReleaseResource(resource, 0u);
 106   resource_pool_->CheckBusyResources();
 107   EXPECT_EQ(1u, resource_provider_->num_resources());
 108
 109   // Different size/format should alloate new resource.
 110   resource = resource_pool_->AcquireResource(gfx::Size(50, 50), LUMINANCE_8);
 111   EXPECT_EQ(2u, resource_provider_->num_resources());
 112   resource_pool_->ReleaseResource(resource, 0u);
 113   resource_pool_->CheckBusyResources();
 114   EXPECT_EQ(2u, resource_provider_->num_resources());
 115 }
 116
 117 TEST_F(ResourcePoolTest, LostResource) {
 118   // Limits high enough to not be hit by this test.
 119   size_t bytes_limit = 10 * 1024 * 1024;
 120   size_t count_limit = 100;
 121   resource_pool_->SetResourceUsageLimits(bytes_limit, bytes_limit, count_limit);
 122
 123   gfx::Size size(100, 100);
 124   ResourceFormat format = RGBA_8888;
 125
 126   Resource* resource = resource_pool_->AcquireResource(size, format);
 127   EXPECT_EQ(1u, resource_provider_->num_resources());
 128
 129   resource_provider_->LoseResourceForTesting(resource->id());
 130   resource_pool_->ReleaseResource(resource, 0u);
 131   resource_pool_->CheckBusyResources();
 132   EXPECT_EQ(0u, resource_provider_->num_resources());
 133 }
 134
 135 }  // namespace
 136 }  // namespace cc