cc: Low quality support for low res tiles

cc/resources/tile_manager.cc

Index: cc/resources/tile_manager.cc
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 8edacf6896dbeeefb13022df1f679404577f09f4..13bb46e488195b5f9c66a97d522f9391416f9922 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -16,6 +16,7 @@
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/tile.h"
+#include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/rect_conversions.h"
 
@@ -23,6 +24,18 @@ namespace cc {
 
 namespace {
 
+class DisableLCDTextFilter : public SkDrawFilter {
+ public:
+  // SkDrawFilter interface.
+  virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
+    if (type != SkDrawFilter::kText_Type)
+      return true;
+
+    paint->setLCDRenderText(false);
+    return true;
+  }
+};
+
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 inline TileManagerBin BinFromTilePriority(const TilePriority& prio) {
@@ -393,6 +406,19 @@ void TileManager::AddRequiredTileForActivation(Tile* tile) {
   tiles_that_need_to_be_initialized_for_activation_.insert(tile);
 }
 
+unsigned TileManager::DetermineRasterFlags(const Tile* tile) const {

[reveman, 2013/06/04 20:16:08]

does this need to be a member function? if not, consider moving it to anonymous
namespace.

[vmpstr, 2013/06/04 22:26:04]

It's a member because it's using Tile's friend TileManager to get access to
managed state

+  DCHECK(tile);
+  DCHECK(tile->picture_pile());
+
+  unsigned raster_flags = 0;
+  if (tile->picture_pile()->can_use_lcd_text())
+    raster_flags |= USE_LCD_TEXT;
+
+  if (tile->managed_state().resolution != LOW_RESOLUTION)
+    raster_flags |= USE_HIGH_QUALITY;
+  return raster_flags;
+}
+
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
 
@@ -447,11 +473,15 @@ void TileManager::AssignGpuMemoryToTiles() {
     if (tile_version.resource_)
       tile_bytes += tile->bytes_consumed_if_allocated();
 
+    unsigned current_raster_flags = tile_version.raster_flags_;
+    unsigned required_raster_flags = DetermineRasterFlags(tile);
+
     // It will cost to allocate a resource.
-    // Note that this is separate from the above condition,
-    // so that it's clear why we're adding memory.
-    if (!tile_version.resource_ && mts.raster_task.is_null())
+    if (mts.raster_task.is_null() &&
+        (!tile_version.resource_ ||
+         (current_raster_flags != required_raster_flags))) {
       tile_bytes += tile->bytes_consumed_if_allocated();
+    }
 
     // Tile is OOM.
     if (tile_bytes > bytes_left) {
@@ -477,8 +507,10 @@ void TileManager::AssignGpuMemoryToTiles() {
     if (higher_priority_tile_oomed)
       continue;
 
-    if (!tile_version.resource_)
+    if (!tile_version.resource_ ||
+        (current_raster_flags != required_raster_flags)) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
+    }
 
     if (!tile_version.resource_ && tile->required_for_activation())
       AddRequiredTileForActivation(tile);
@@ -562,7 +594,8 @@ void TileManager::ScheduleTasks() {
     ManagedTileState& mts = tile->managed_state();
 
     DCHECK(tile->tile_version().requires_resource());
-    DCHECK(!tile->tile_version().resource_);
+    DCHECK(!tile->tile_version().resource_ ||
+           (tile->tile_version().raster_flags_ != DetermineRasterFlags(tile)));
 
     // Create raster task for this tile if necessary.
     if (mts.raster_task.is_null())
@@ -611,6 +644,7 @@ TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
   metadata.layer_id = tile.layer_id();
   metadata.tile_id = &tile;
   metadata.source_frame_number = tile.source_frame_number();
+  metadata.raster_flags = DetermineRasterFlags(&tile);
   return metadata;
 }
 
@@ -656,6 +690,7 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
     pending_decode_tasks_[id] = decode_task;
   }
 
+  RasterTaskMetadata metadata = GetRasterTaskMetadata(*tile);
   return RasterWorkerPool::RasterTask(
       tile->picture_pile(),
       const_resource,
@@ -665,19 +700,20 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
                             tile->content_rect(),
                             tile->contents_scale(),
                             use_color_estimator_,
-                            GetRasterTaskMetadata(*tile),
+                            metadata,
                             rendering_stats_instrumentation_),
                  base::Bind(&TileManager::RunRasterTask,
                             analysis,
                             tile->content_rect(),
                             tile->contents_scale(),
-                            GetRasterTaskMetadata(*tile),
+                            metadata,
                             rendering_stats_instrumentation_)),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  make_scoped_refptr(tile),
                  base::Passed(&resource),
-                 base::Owned(analysis)),
+                 base::Owned(analysis),
+                 metadata.raster_flags),
       &decode_tasks);
 }
 
@@ -685,6 +721,7 @@ void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     PicturePileImpl::Analysis* analysis,
+    unsigned raster_flags,
     bool was_canceled) {
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
@@ -698,6 +735,12 @@ void TileManager::OnRasterTaskCompleted(
     return;
   }
 
+  if (tile->tile_version().resource_) {
+    resource_pool_->ReleaseResource(tile->tile_version().resource_.Pass());
+    DCHECK(tile->tile_version().raster_flags_ != raster_flags);
+    tile->tile_version().raster_flags_ = INVALID_RASTER_FLAG;
+  }
+
   mts.picture_pile_analysis = *analysis;
   mts.picture_pile_analyzed = true;
 
@@ -706,6 +749,12 @@ void TileManager::OnRasterTaskCompleted(
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile->tile_version().resource_ = resource.Pass();
+    tile->tile_version().raster_flags_ = raster_flags;
+
+    // If we already need a new version, schedule ManageTiles() call.
+    unsigned required_raster_flags = DetermineRasterFlags(tile.get());
+    if (required_raster_flags != raster_flags)
+      client_->ScheduleManageTiles();

[reveman, 2013/06/04 20:16:08]

how will this work with https://codereview.chromium.org/15855008/ ?

what if this task was canceled? and wouldn't we want this canceled and the task
with the correct raster flags to be scheduled asap instead of having to wait for
this to complete?

   }
 
   DidFinishTileInitialization(tile.get());
@@ -791,6 +840,7 @@ scoped_ptr<base::Value> TileManager::RasterTaskMetadata::AsValue() const {
                   is_tile_in_pending_tree_now_bin);
   res->Set("resolution", TileResolutionAsValue(tile_resolution).release());
   res->SetInteger("source_frame_number", source_frame_number);
+  res->SetInteger("raster_flags", raster_flags);
   return res.PassAs<base::Value>();
 }
 
@@ -818,6 +868,14 @@ bool TileManager::RunRasterTask(
 
   SkCanvas canvas(device);
 
+  skia::RefPtr<SkDrawFilter> draw_filter;
+  if ((metadata.raster_flags & USE_HIGH_QUALITY) == 0)
+    draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
+  else if ((metadata.raster_flags & USE_LCD_TEXT) == 0)
+    draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
+
+  canvas.setDrawFilter(draw_filter.get());
+
   if (stats_instrumentation->record_rendering_stats()) {
     PicturePileImpl::RasterStats raster_stats;
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, &raster_stats);