Reland Allow one-copy and zero-copy task tile worker pools to use compressed textures.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 34 matching lines @@
 
 // Even for really wide viewports, at some point GPU raster should use
 // less than 4 tiles to fill the viewport. This is set to 256 as a
 // sane minimum for now, but we might want to tune this for low-end.
 const int kMinHeightForGpuRasteredTile = 256;
 
 // When making odd-sized tiles, round them up to increase the chances
 // of using the same tile size.
 const int kTileRoundUp = 64;
 
+// For performance reasons and to support compressed tile textures, tile
+// width and height should be an even multiple of 4 in size.
+const int kTileMinimalAlignment = 4;
+
 }  // namespace
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
     bool is_mask,
     scoped_refptr<SyncedScrollOffset> scroll_offset)
     : LayerImpl(tree_impl, id, scroll_offset),
@@ skipping 709 matching lines @@
     tile_width = std::min(tile_width, content_bounds.width());
     tile_width = MathUtil::UncheckedRoundUp(tile_width, kTileRoundUp);
     tile_width = std::min(tile_width, default_tile_width);
   }
   if (content_bounds.height() < default_tile_height) {
     tile_height = std::min(tile_height, content_bounds.height());
     tile_height = MathUtil::UncheckedRoundUp(tile_height, kTileRoundUp);
     tile_height = std::min(tile_height, default_tile_height);
   }
 
+  // Ensure that tile width and height are properly aligned.
+  tile_width = MathUtil::UncheckedRoundUp(tile_width, kTileMinimalAlignment);
+  tile_height = MathUtil::UncheckedRoundUp(tile_height, kTileMinimalAlignment);
+
   // Under no circumstance should we be larger than the max texture size.
   tile_width = std::min(tile_width, max_texture_size);
   tile_height = std::min(tile_height, max_texture_size);
   return gfx::Size(tile_width, tile_height);
 }
 
 void PictureLayerImpl::GetContentsResourceId(ResourceId* resource_id,
                                              gfx::Size* resource_size) const {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
@@ skipping 462 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc