Allow task pools to reason about transparency.

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 509 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 119 matching lines @@
   uint64_t resource_content_id = 0;
   Resource* resource = nullptr;
   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));
   }
 
   // Create and queue all image decode tasks that this tile depends on.
   ImageDecodeTask::Vector decode_tasks;
   std::vector<skia::PositionImage> images;
   prioritized_tile.raster_source()->GatherDiscardableImages(
       tile->enclosing_layer_rect(), &images);
   for (const skia::PositionImage& image : images) {
     decode_tasks.push_back(image_decode_controller_.GetTaskForImage(
         image, tile->layer_id(), prepare_tiles_count_));
@@ skipping 44 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, tile->invalidated_id());
     }
   } else {
     DCHECK(resource);
     draw_info.set_use_resource();
     draw_info.resource_ = resource;
-    draw_info.contents_swizzled_ =
-        tile_task_runner_->GetResourceRequiresSwizzle();
+    draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
   }
   DCHECK(draw_info.IsReadyToDraw());
   draw_info.set_was_ever_ready_to_draw();
 
   client_->NotifyTileStateChanged(tile);
 }
 
 ScopedTilePtr TileManager::CreateTile(const Tile::CreateInfo& info,
                                       int layer_id,
                                       int source_frame_number,
@@ skipping 160 matching lines @@
     client_->NotifyTileStateChanged(tile);
   }
 
   DCHECK(IsReadyToActivate());
   // TODO(ericrk): Investigate why we need to schedule this (not just call it
   // inline). http://crbug.com/498439
   signals_.ready_to_activate = true;
   signals_check_notifier_.Schedule();
 }
 
+ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const {
+  return tile_task_runner_->GetResourceFormat(!tile->is_opaque());
+}
+
+bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
+  return tile_task_runner_->GetResourceRequiresSwizzle(!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 57 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc