Tile Compression

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 191 matching lines @@
   state->SetInteger("canceled_count", stats.canceled_count);
   return state;
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
+    int compression_threshold,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     size_t scheduled_raster_task_limit) {
-  return make_scoped_ptr(new TileManager(
-      client, task_runner, resource_pool, tile_task_runner,
-      rendering_stats_instrumentation, scheduled_raster_task_limit));
+  return make_scoped_ptr(
+      new TileManager(client, task_runner, resource_pool, tile_task_runner,
+                      compression_threshold, rendering_stats_instrumentation,
+                      scheduled_raster_task_limit));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
+    int compression_threshold,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     size_t scheduled_raster_task_limit)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(resource_pool),
       tile_task_runner_(tile_task_runner),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
+      compression_threshold_(compression_threshold),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
       did_notify_ready_to_activate_(false),
       did_notify_ready_to_draw_(false) {
   tile_task_runner_->SetClient(this);
@@ skipping 339 matching lines @@
     DCHECK(mts.draw_info.mode() ==
                ManagedTileState::DrawInfo::PICTURE_PILE_MODE ||
            !mts.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 (!mts.raster_task.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
-          tile->size(), resource_pool_->resource_format());
+          tile->size(),
+          resource_pool_->resource_format(DetermineResourceFormatUsage(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 35 matching lines @@
   raster_priority_queue_.Reset();
 
   TRACE_EVENT_END2("cc",
                    "TileManager::AssignGpuMemoryToTiles",
                    "all_tiles_that_need_to_be_rasterized_are_scheduled",
                    all_tiles_that_need_to_be_rasterized_are_scheduled_,
                    "had_enough_memory_to_schedule_tiles_needed_now",
                    had_enough_memory_to_schedule_tiles_needed_now);
 }
 
+ResourceFormatUsage TileManager::DetermineResourceFormatUsage(
+    const Tile* tile) const {
+  ResourceFormatUsage usage;
+  if (tile->size().width() % 4 != 0 || tile->size().height() % 4 != 0 ||
+      tile->frequently_invalidated()) {
+    usage = FORMAT_USAGE_NATIVE;
+  } else {
+    usage = tile->IsOpaque() ? FORMAT_USAGE_OPAQUE : FORMAT_USAGE_TRANSLUCENT;
+    // Urgent tiles can be generated faster if we avoid memory optimized
+    // formats.
+    if (compression_threshold_ >= 0) {
+      TilePriority::PriorityBin bin = tile->combined_priority().priority_bin;
+      if (static_cast<int>(bin) < compression_threshold_) {
+        usage = FORMAT_USAGE_NATIVE;
+      }
+    }
+  }
+  return usage;
+}
+
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.draw_info.resource_)
     resource_pool_->ReleaseResource(mts.draw_info.resource_.Pass());
 }
 
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->IsReadyToDraw();
   FreeResourcesForTile(tile);
@@ skipping 62 matching lines @@
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref))));
 }
 
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
-  scoped_ptr<ScopedResource> resource =
-      resource_pool_->AcquireResource(tile->size());
+  scoped_ptr<ScopedResource> resource = resource_pool_->AcquireResource(
+      tile->size(), DetermineResourceFormatUsage(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;
   tile->raster_source()->GatherPixelRefs(
       tile->content_rect(), tile->contents_scale(), &pixel_refs);
   for (SkPixelRef* pixel_ref : pixel_refs) {
     uint32_t id = pixel_ref->getGenerationID();
@@ skipping 207 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