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                                NULL,
  29                                0,
  30                                false,
  31                                1));
  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                                NULL,
  55                                0,
  56                                false,
  57                                1));
  58   scoped_ptr<ScopedResource> texture =
  59       ScopedResource::Create(resource_provider.get());
  60   texture->Allocate(gfx::Size(30, 30), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
  61                     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                                NULL,
  84                                0,
  85                                false,
  86                                1));
  87   {
  88     scoped_ptr<ScopedResource> texture =
  89         ScopedResource::Create(resource_provider.get());
  90
  91     EXPECT_EQ(0u, resource_provider->num_resources());
  92     texture->Allocate(gfx::Size(30, 30),
  93                       ResourceProvider::TEXTURE_HINT_IMMUTABLE, 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(gfx::Size(30, 30),
 104                       ResourceProvider::TEXTURE_HINT_IMMUTABLE, 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 }  // namespace
 113 }  // namespace cc