src/cc/resources/scoped_resource_unittest.cc

   1 // Copyright 2012 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/scoped_resource.h"
   6
   7 #include "cc/output/renderer.h"
   8 #include "cc/test/fake_output_surface.h"
   9 #include "cc/test/fake_output_surface_client.h"
  10 #include "cc/test/test_shared_bitmap_manager.h"
  11 #include "cc/test/tiled_layer_test_common.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace cc {
  15 namespace {
  16
  17 TEST(ScopedResourceTest, NewScopedResource) {
  18   FakeOutputSurfaceClient output_surface_client;
  19   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d());
  20   CHECK(output_surface->BindToClient(&output_surface_client));
  21
  22   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
  23       new TestSharedBitmapManager());
  24   scoped_ptr<ResourceProvider> resource_provider(
  25       ResourceProvider::Create(output_surface.get(),
  26                                shared_bitmap_manager.get(),
  27                                NULL,
  28                                0,
  29                                false,
  30                                1,
  31                                false));
  32   scoped_ptr<ScopedResource> texture =
  33       ScopedResource::Create(resource_provider.get());
  34
  35   // New scoped textures do not hold a texture yet.
  36   EXPECT_EQ(0u, texture->id());
  37
  38   // New scoped textures do not have a size yet.
  39   EXPECT_EQ(gfx::Size(), texture->size());
  40   EXPECT_EQ(0u, texture->bytes());
  41 }
  42
  43 TEST(ScopedResourceTest, CreateScopedResource) {
  44   FakeOutputSurfaceClient output_surface_client;
  45   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d());
  46   CHECK(output_surface->BindToClient(&output_surface_client));
  47
  48   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
  49       new TestSharedBitmapManager());
  50   scoped_ptr<ResourceProvider> resource_provider(
  51       ResourceProvider::Create(output_surface.get(),
  52                                shared_bitmap_manager.get(),
  53                                NULL,
  54                                0,
  55                                false,
  56                                1,
  57                                false));
  58   scoped_ptr<ScopedResource> texture =
  59       ScopedResource::Create(resource_provider.get());
  60   texture->Allocate(
  61       gfx::Size(30, 30), ResourceProvider::TextureHintImmutable, RGBA_8888);
  62
  63   // The texture has an allocated byte-size now.
  64   size_t expected_bytes = 30 * 30 * 4;
  65   EXPECT_EQ(expected_bytes, texture->bytes());
  66
  67   EXPECT_LT(0u, texture->id());
  68   EXPECT_EQ(static_cast<unsigned>(RGBA_8888), texture->format());
  69   EXPECT_EQ(gfx::Size(30, 30), texture->size());
  70 }
  71
  72 TEST(ScopedResourceTest, ScopedResourceIsDeleted) {
  73   FakeOutputSurfaceClient output_surface_client;
  74   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d());
  75   CHECK(output_surface->BindToClient(&output_surface_client));
  76
  77   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
  78       new TestSharedBitmapManager());
  79   scoped_ptr<ResourceProvider> resource_provider(
  80       ResourceProvider::Create(output_surface.get(),
  81                                shared_bitmap_manager.get(),
  82                                NULL,
  83                                0,
  84                                false,
  85                                1,
  86                                false));
  87   {
  88     scoped_ptr<ScopedResource> texture =
  89         ScopedResource::Create(resource_provider.get());
  90
  91     EXPECT_EQ(0u, resource_provider->num_resources());
  92     texture->Allocate(
  93         gfx::Size(30, 30), ResourceProvider::TextureHintImmutable, RGBA_8888);
  94     EXPECT_LT(0u, texture->id());
  95     EXPECT_EQ(1u, resource_provider->num_resources());
  96   }
  97
  98   EXPECT_EQ(0u, resource_provider->num_resources());
  99   {
 100     scoped_ptr<ScopedResource> texture =
 101         ScopedResource::Create(resource_provider.get());
 102     EXPECT_EQ(0u, resource_provider->num_resources());
 103     texture->Allocate(
 104         gfx::Size(30, 30), ResourceProvider::TextureHintImmutable, RGBA_8888);
 105     EXPECT_LT(0u, texture->id());
 106     EXPECT_EQ(1u, resource_provider->num_resources());
 107     texture->Free();
 108     EXPECT_EQ(0u, resource_provider->num_resources());
 109   }
 110 }
 111
 112 TEST(ScopedResourceTest, LeakScopedResource) {
 113   FakeOutputSurfaceClient output_surface_client;
 114   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d());
 115   CHECK(output_surface->BindToClient(&output_surface_client));
 116
 117   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
 118       new TestSharedBitmapManager());
 119   scoped_ptr<ResourceProvider> resource_provider(
 120       ResourceProvider::Create(output_surface.get(),
 121                                shared_bitmap_manager.get(),
 122                                NULL,
 123                                0,
 124                                false,
 125                                1,
 126                                false));
 127   {
 128     scoped_ptr<ScopedResource> texture =
 129         ScopedResource::Create(resource_provider.get());
 130
 131     EXPECT_EQ(0u, resource_provider->num_resources());
 132     texture->Allocate(
 133         gfx::Size(30, 30), ResourceProvider::TextureHintImmutable, RGBA_8888);
 134     EXPECT_LT(0u, texture->id());
 135     EXPECT_EQ(1u, resource_provider->num_resources());
 136
 137     texture->Leak();
 138     EXPECT_EQ(0u, texture->id());
 139     EXPECT_EQ(1u, resource_provider->num_resources());
 140
 141     texture->Free();
 142     EXPECT_EQ(0u, texture->id());
 143     EXPECT_EQ(1u, resource_provider->num_resources());
 144   }
 145
 146   EXPECT_EQ(1u, resource_provider->num_resources());
 147 }
 148
 149 }  // namespace
 150 }  // namespace cc