Implement on demand quad rasterization for PicturePiles.

cc/resources/resource_provider.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 <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
@@ skipping 251 matching lines @@
   ResourceId id = next_id_++;
   unsigned texture_id = 0;
   Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR);
   resource.external = true;
   resource.allocated = true;
   resource.mailbox = mailbox;
   resources_[id] = resource;
   return id;
 }
 
+void ResourceProvider::ResizeResource(ResourceId id, gfx::Size size) {
+  DCHECK_LE(size.width(), max_texture_size_);
+  DCHECK_LE(size.height(), max_texture_size_);

[piman, 2013/03/22 18:03:03]

Note: you're only handling GL resources. You should handle the other types too
(where the max texture size doesn't apply).

[Leandro Graciá Gil, 2013/03/22 20:40:58]

Done.

+  DCHECK(thread_checker_.CalledOnValidThread());
+  ResourceMap::iterator it = resources_.find(id);
+  CHECK(it != resources_.end());
+  Resource* resource = &it->second;
+  DCHECK(!resource->lock_for_read_count);
+  DCHECK(!resource->marked_for_deletion);
+  DCHECK(resource->pending_set_pixels || !resource->locked_for_write);

[piman, 2013/03/22 18:03:03]

I'm not sure about this if pending_set_pixels is set, you should double-check
with epenner/reveman.

[epenner, 2013/03/22 22:31:00]

I added reveman to review as well.

I believe the pending flag is okay as it will still complete first before the
resize. However! Async textures are immutable and can't be resized. This is
similar to texStorage2DEXT which we might also want to use in here as it's nicer
for GL implementations.

Would it make sense to just delete the texture completely? That's effectively
what happens on resize anyway, and is the only way to resize async or
glTexStorage2D textures.

+  DCHECK(!resource->exported);

[piman, 2013/03/22 18:03:03]

Check that it's not external (you shouldn't be resizing resources that are not
managed by the RP).
Also, check that you have no gl_pixel_buffer_id, nor any pixel_buffer, since
those would be wrongly sized.

[Leandro Graciá Gil, 2013/03/22 20:40:58]

Done.

+
+  if (resource->size != size) {
+    resource->size = size;
+    resource->allocated = false;

[piman, 2013/03/22 18:03:03]

This is ok for GL resources (LazyAllocate will resize), but for bitmap
resources, it should reallocate pixels (currently bitmaps aren't
lazy-allocated).

[Leandro Graciá Gil, 2013/03/22 20:40:58]

Done.

+  }
+}
+
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->lock_for_read_count);
   DCHECK(!resource->marked_for_deletion);
   DCHECK(resource->pending_set_pixels || !resource->locked_for_write);
 
   if (resource->exported) {
@@ skipping 920 matching lines @@
 void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   resource->enable_read_lock_fences = enable;
 }
 
 }  // namespace cc