Implement on demand quad rasterization for PicturePiles.

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 "base/bind.h"
 #include "base/logging.h"
 #include "cc/base/scoped_ptr_deque.h"
 #include "cc/base/scoped_ptr_hash_map.h"
@@ skipping 249 matching lines @@
     memcpy(pixels, texture->data.get(), TextureSize(size, format));
   }
 
   WGC3Denum GetTextureFilter() {
     DCHECK(current_texture_);
     Texture* texture = textures_.get(current_texture_);
     DCHECK(texture);
     return texture->filter;
   }
 
+  gfx::Size GetCurrentTextureSize() {
+    DCHECK(current_texture_);
+    Texture* texture = textures_.get(current_texture_);
+    DCHECK(texture);
+    return texture->size;
+  }
+
   int texture_count() { return textures_.size(); }
 
  protected:
   ResourceProviderContext(const Attributes& attrs,
                           ContextSharedData* shared_data)
       : TestWebGraphicsContext3D(attrs),
         shared_data_(shared_data),
         current_texture_(0),
         last_waited_sync_point_(0) {}
 
@@ skipping 856 matching lines @@
   id = resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   resource_provider->AcquirePixelBuffer(id);
   resource_provider->BeginSetPixels(id);
   resource_provider->ForceSetPixelsToComplete(id);
   resource_provider->AbortSetPixels(id);
   resource_provider->ReleasePixelBuffer(id);
   Mock::VerifyAndClearExpectations(context);
 }
 
+void CheckResourceSize(
+    ResourceProvider* resource_provider,
+    ResourceProviderContext* context,
+    ResourceProvider::ResourceId id,
+    gfx::Size size) {
+  switch (resource_provider->GetResourceType(id)) {
+    case ResourceProvider::GLTexture: {
+      // Enforce texture allocation.
+      ResourceProvider::ScopedWriteLockGL lock(resource_provider, id);
+      EXPECT_EQ(context->GetCurrentTextureSize(), size);
+      break;
+    }
+    case ResourceProvider::Bitmap: {
+      ResourceProvider::ScopedReadLockSoftware lock(resource_provider, id);
+      EXPECT_EQ(lock.sk_bitmap()->width(), size.width());
+      EXPECT_EQ(lock.sk_bitmap()->height(), size.height());
+
+      // Ensure bitmap pixels were allocated during resize.
+      lock.sk_bitmap()->lockPixels();
+      EXPECT_TRUE(lock.sk_bitmap()->getPixels());
+      lock.sk_bitmap()->unlockPixels();
+      break;
+    }
+    default:

[piman, 2013/03/22 20:52:34]

nit: no need for default clause.

+      NOTREACHED();
+      break;
+  }
+}
+
+TEST_P(ResourceProviderTest, ResizeResource) {
+  gfx::Size size(1, 2);
+  ResourceProvider::ResourceId id = resource_provider_->CreateResource(
+      size,
+      GL_RGBA,
+      ResourceProvider::TextureUsageAny);
+  ExpectNumResources(1);
+
+  CheckResourceSize(resource_provider_.get(), context(), id, size);
+
+  gfx::Size new_size(3, 4);
+  resource_provider_->ResizeResource(id, new_size);
+  ExpectNumResources(1);
+
+  CheckResourceSize(resource_provider_.get(), context(), id, new_size);
+
+  resource_provider_->DeleteResource(id);
+  ExpectNumResources(0);
+}
+
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc