Allow one-copy task tile worker pool to use compressed textures.

cc/resources/resource_pool.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_pool.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 71 matching lines @@
     DidFinishUsingResource(busy_resources_.take_front());
   }
 
   SetResourceUsageLimits(0, 0);
   DCHECK_EQ(0u, unused_resources_.size());
   DCHECK_EQ(0u, in_use_memory_usage_bytes_);
   DCHECK_EQ(0u, total_memory_usage_bytes_);
   DCHECK_EQ(0u, total_resource_count_);
 }
 
-Resource* ResourcePool::AcquireResource(const gfx::Size& size,
+Resource* ResourcePool::AcquireResource(const gfx::Size& desired_size,

[reveman, 2015/09/30 09:55:15]

Can we instead just make sure resource dimensions are always multiple of 4 and
have a DCHECK here independent of format? It doesn't make sense for us to ever
use a different resource size as that can easily result in worse performance as
the starting address of each row might not be 8 byte aligned.

[christiank, 2015/11/26 15:35:35]

I guess that makes sense. I am not sure if there are specific use cases for
other sizes now that I think about it. I can vaguely recall something about
video elements or WebGL introducing a layer with an odd size.

Do you have any hints on where I can look to restrict the resource size?

[reveman, 2015/11/27 16:46:49]

https://code.google.com/p/chromium/codesearch#chromium/src/cc/layers/picture_...

[christiank, 2015/11/30 15:41:08]

Perfect, thanks! Will look at this tomorrow.

[christiank, 2015/12/01 15:01:07]

Should now be fixed.

                                         ResourceFormat format) {
+  gfx::Size size = desired_size;
+  if (IsResourceFormatCompressed(format) &&
+      (size.width() % 4 != 0 || size.height() % 4 != 0)) {
+    // Round the size up to the nearest multiple of four.
+    size.SetSize(4 * std::ceil(static_cast<float>(size.width()) / 4),
+                 4 * std::ceil(static_cast<float>(size.height()) / 4));
+  }
+
   for (ResourceDeque::iterator it = unused_resources_.begin();
        it != unused_resources_.end(); ++it) {
     ScopedResource* resource = *it;
     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
     if (resource->format() != format)
       continue;
     if (resource->size() != size)
       continue;
 
@@ skipping 192 matching lines @@
   for (const auto& resource : busy_resources_) {
     resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   for (const auto& entry : in_use_resources_) {
     entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   return true;
 }
 
 }  // namespace cc