Remaining code for basic tile compression functionality.

cc/tiles/tile_manager.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/tiles/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 525 matching lines @@
 
     DCHECK_IMPLIES(tile->draw_info().mode() != TileDrawInfo::OOM_MODE,
                    !tile->draw_info().IsReadyToDraw());
 
     // If the tile already has a raster_task, then the memory used by it is
     // already accounted for in memory_usage. Otherwise, we'll have to acquire
     // more memory to create a raster task.
     MemoryUsage memory_required_by_tile_to_be_scheduled;
     if (!tile->raster_task_.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
-          tile->desired_texture_size(), tile_task_runner_->GetResourceFormat());
+          tile->desired_texture_size(), DetermineResourceFormat(tile));
     }
 
     bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
 
     // This is the memory limit that will be used by this tile. Depending on
     // the tile priority, it will be one of hard_memory_limit or
     // soft_memory_limit.
     MemoryUsage& tile_memory_limit =
         tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
 
@@ skipping 123 matching lines @@
   uint64_t resource_content_id = 0;
   scoped_ptr<ScopedResource> resource;
   if (tile->invalidated_id()) {
     // TODO(danakj): For resources that are in use, we should still grab them
     // and copy from them instead of rastering everything. crbug.com/492754
     resource =
         resource_pool_->TryAcquireResourceWithContentId(tile->invalidated_id());
   }
   if (resource) {
     resource_content_id = tile->invalidated_id();
-    DCHECK_EQ(tile_task_runner_->GetResourceFormat(), resource->format());
+    DCHECK_EQ(DetermineResourceFormat(tile), resource->format());
     DCHECK_EQ(tile->desired_texture_size().ToString(),
               resource->size().ToString());
   } else {
-    resource = resource_pool_->AcquireResource(
-        tile->desired_texture_size(), tile_task_runner_->GetResourceFormat());
+    resource = resource_pool_->AcquireResource(tile->desired_texture_size(),
+                                               DetermineResourceFormat(tile));
   }
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   std::vector<SkPixelRef*> pixel_refs;
   prioritized_tile.raster_source()->GatherPixelRefs(
       tile->content_rect(), tile->contents_scale(), &pixel_refs);
   for (SkPixelRef* pixel_ref : pixel_refs) {
@@ skipping 78 matching lines @@
     draw_info.set_solid_color(analysis.solid_color);
     if (resource) {
       // Pass the old tile id here because the tile is solid color so we did not
       // raster anything into the tile resource.
       resource_pool_->ReleaseResource(resource.Pass(), tile->invalidated_id());
     }
   } else {
     DCHECK(resource);
     draw_info.set_use_resource();
     draw_info.resource_ = resource.Pass();
-    draw_info.contents_swizzled_ =
-        tile_task_runner_->GetResourceRequiresSwizzle();
+    draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
   }
   client_->NotifyTileStateChanged(tile);
 }
 
 ScopedTilePtr TileManager::CreateTile(const gfx::Size& desired_texture_size,
                                       const gfx::Rect& content_rect,
                                       float contents_scale,
                                       int layer_id,
                                       int source_frame_number,
                                       int flags) {
@@ skipping 155 matching lines @@
        required_for_activation_queue->Pop()) {
     Tile* tile = required_for_activation_queue->Top().tile();
     tile->draw_info().set_oom();
     client_->NotifyTileStateChanged(tile);
   }
 
   DCHECK(IsReadyToActivate());
   ready_to_activate_check_notifier_.Schedule();
 }
 
+ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const {
+  bool dont_compress = tile->desired_texture_size().width() % 4 != 0 ||
+                       tile->desired_texture_size().height() % 4 != 0;

[reveman, 2015/07/21 04:26:33]

Can we instead clamp tile size to multiple of 4 if that's not already done so
that we never have to worry about not being able to use compression because of
tile size?

+  return tile_task_runner_->GetResourceFormat(dont_compress,
+                                              !tile->is_opaque());
+}
+
+bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
+  bool dont_compress = tile->desired_texture_size().width() % 4 != 0 ||
+                       tile->desired_texture_size().height() % 4 != 0;
+  return tile_task_runner_->GetResourceRequiresSwizzle(dont_compress,
+                                                       !tile->is_opaque());
+}
+
 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
 }
 
 TileManager::MemoryUsage::MemoryUsage(size_t memory_bytes,
                                       size_t resource_count)
     : memory_bytes_(static_cast<int64>(memory_bytes)),
       resource_count_(static_cast<int>(resource_count)) {
   // MemoryUsage is constructed using size_ts, since it deals with memory and
   // the inputs are typically size_t. However, during the course of usage (in
   // particular operator-=) can cause internal values to become negative. Thus,
@@ skipping 43 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc