cc: Stop using TextureUploader for UIResources, HUD, and tests.

cc/resources/resource_provider_unittest.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_provider.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 
@@ skipping 504 matching lines @@
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   EXPECT_EQ(1, static_cast<int>(resource_provider->num_resources()));
   if (expected_default_type == ResourceProvider::GLTexture)
     EXPECT_EQ(0u, context->NumTextures());
 
   uint8_t data[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
+  resource_provider->CopyToResource(id, data, size);
   if (expected_default_type == ResourceProvider::GLTexture)
     EXPECT_EQ(1u, context->NumTextures());
 
   uint8_t result[4] = { 0 };
   GetResourcePixels(resource_provider, context, id, size, format, result);
   EXPECT_EQ(0, memcmp(data, result, pixel_size));
 
   resource_provider->DeleteResource(id);
   EXPECT_EQ(0, static_cast<int>(resource_provider->num_resources()));
   if (expected_default_type == ResourceProvider::GLTexture)
@@ skipping 64 matching lines @@
 
     uint8_t expected[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3 };
     GetResourcePixels(
         resource_provider_.get(), context(), id, size, format, result);
     EXPECT_EQ(0, memcmp(expected, result, pixel_size));
   }
 
   resource_provider_->DeleteResource(id);
 }
 
+TEST_P(ResourceProviderTest, SimpleUpload) {
+  gfx::Size size(2, 2);
+  ResourceFormat format = RGBA_8888;
+  size_t pixel_size = TextureSizeBytes(size, format);
+  ASSERT_EQ(16U, pixel_size);
+
+  ResourceProvider::ResourceId id = resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
+
+  uint8_t image[16] = {0};
+  resource_provider_->CopyToResource(id, image, size);
+  {
+    uint8_t result[16] = {0};
+    uint8_t expected[16] = {0};
+    GetResourcePixels(resource_provider_.get(), context(), id, size, format,
+                      result);
+    EXPECT_EQ(0, memcmp(expected, result, pixel_size));
+  }
+
+  for (uint8_t i = 0; i < pixel_size; ++i)
+    image[i] = i;
+  resource_provider_->CopyToResource(id, image, size);
+  {
+    uint8_t result[16] = {0};
+    uint8_t expected[16] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    GetResourcePixels(resource_provider_.get(), context(), id, size, format,
+                      result);
+    EXPECT_EQ(0, memcmp(expected, result, pixel_size));
+  }
+}
+
 TEST_P(ResourceProviderTest, TransferGLResources) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id1, data1, size);
 
   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data2[4] = { 5, 5, 5, 5 };
-  child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id2, data2, size);
 
   ResourceProvider::ResourceId id3 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   {
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         child_resource_provider_.get(), id3);
     EXPECT_TRUE(!!lock.GetGpuMemoryBuffer());
   }
 
   GLuint external_texture_id = child_context_->createExternalTexture();
@@ skipping 217 matching lines @@
 
 TEST_P(ResourceProviderTest, ReadLockCountStopsReturnToChildOrDelete) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = {1, 2, 3, 4};
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id1, data1, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 84 matching lines @@
     return;
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id1, data1, size);
 
   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data2[4] = { 5, 5, 5, 5 };
-  child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id2, data2, size);
 
   scoped_ptr<SharedBitmap> shared_bitmap(CreateAndFillSharedBitmap(
       shared_bitmap_manager_.get(), gfx::Size(1, 1), 0));
   SharedBitmap* shared_bitmap_ptr = shared_bitmap.get();
   ResourceProvider::ResourceId id3 =
       child_resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(shared_bitmap_ptr, gfx::Size(1, 1)),
           SingleReleaseCallbackImpl::Create(base::Bind(
               &SharedBitmapReleaseCallback, base::Passed(&shared_bitmap))));
 
@@ skipping 175 matching lines @@
                                1));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  child_resource_provider->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider->CopyToResource(id1, data1, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     TransferableResourceArray list;
     child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
                                                  &list);
@@ skipping 25 matching lines @@
     return;
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id1, data1, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
@@ skipping 26 matching lines @@
 
 TEST_P(ResourceProviderTest, DeleteExportedResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id1, data1, size);
 
   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data2[4] = {5, 5, 5, 5};
-  child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id2, data2, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     TransferableResourceArray list;
@@ skipping 67 matching lines @@
 
 TEST_P(ResourceProviderTest, DestroyChildWithExportedResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data1[4] = {1, 2, 3, 4};
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id1, data1, size);
 
   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data2[4] = {5, 5, 5, 5};
-  child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id2, data2, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     TransferableResourceArray list;
@@ skipping 84 matching lines @@
 
 TEST_P(ResourceProviderTest, DeleteTransferredResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data[4] = { 1, 2, 3, 4 };
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id, data, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 28 matching lines @@
 
 TEST_P(ResourceProviderTest, UnuseTransferredResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   uint8_t data[4] = {1, 2, 3, 4};
-  gfx::Rect rect(size);
-  child_resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
+  child_resource_provider_->CopyToResource(id, data, size);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   const ResourceProvider::ResourceIdMap& map =
       resource_provider_->GetChildToParentMap(child_id);
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
@@ skipping 152 matching lines @@
         *child_context,
         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     EXPECT_CALL(*child_context,
                 texParameteri(GL_TEXTURE_2D,
                               GL_TEXTURE_POOL_CHROMIUM,
                               GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
     child_resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(child_context);
 
     uint8_t data[4] = { 1, 2, 3, 4 };
-    gfx::Rect rect(size);
 
     EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
-    child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
+    child_resource_provider->CopyToResource(id, data, size);
     Mock::VerifyAndClearExpectations(child_context);
 
     // The texture is set to |child_filter| in the child.
     EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
     if (child_filter != GL_LINEAR) {
       EXPECT_CALL(
           *child_context,
           texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, child_filter));
       EXPECT_CALL(
           *child_context,
@@ skipping 1316 matching lines @@
       ResourceProvider::Create(output_surface.get(),
                                shared_bitmap_manager_.get(),
                                gpu_memory_buffer_manager_.get(),
                                NULL,
                                0,
                                false,
                                1));
 
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
-  gfx::Rect rect(0, 0, 2, 2);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
 
   // Lazy allocation. Don't allocate when creating the resource.
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   resource_provider->CreateForTesting(id);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 
   // Do allocate when we set the pixels.
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
   EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
-  resource_provider->SetPixels(id, pixels, rect, rect, offset);
+  resource_provider->CopyToResource(id, pixels, size);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
 
   // Same for async version.
   id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   resource_provider->AcquirePixelBuffer(id);
@@ skipping 512 matching lines @@
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, ETC1);
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   resource_provider->AllocateForTesting(id);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
-TEST_P(ResourceProviderTest, CompressedTextureETC1SetPixels) {
+TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) {
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
   scoped_ptr<AllocationTrackingContext3D> context_owned(
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
@@ skipping 13 matching lines @@
   uint8_t pixels[8];
 
   ResourceProvider::ResourceId id = resource_provider->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, ETC1);
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context,
               compressedTexImage2D(
                   _, 0, _, size.width(), size.height(), _, _, _)).Times(1);
-  resource_provider->SetPixels(
-      id, pixels, gfx::Rect(size), gfx::Rect(size), gfx::Vector2d(0, 0));
+  resource_provider->CopyToResource(id, pixels, size);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
@@ skipping 61 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc