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 f965981ffaa16ef8cec1b58136c2ea1c11412cdf..837985a9600f6dc02a04ad557c8b3433e62dd2ad 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 {
+  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");
 
@@ -446,11 +472,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);

[reveman, 2013/06/04 16:17:12]

What causes required_raster_flags to change and how is it triggering a call to
ManagedTiles?

[vmpstr, 2013/06/04 16:59:08]

the quality right now depends on the tile resolution, so if the resolution is
changed, then we call ManageTiles, right? I'm kind of basing it on this
assumption. Likewise with lcd text, it's currently immutable property on a
picture pile. When a tile is updated with a new picture, then we definitely
re-raster it.

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

How come TileRasterFlags is not just part of the TilePriority? Do you expect
some global state to affect this in the future?

+
     // 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))) {

[reveman, 2013/06/04 16:17:12]

what if !mts.raster_task.is_null() but current_raster_flags !=
required_raster_flags. we want a new tile version in that case but can't
initiate one as there's already a pending raster task for this tile. when that
pending raster task completes, what will trigger this new task to be created?

[vmpstr, 2013/06/04 16:59:08]

I've added a check in raster task completion.

       tile_bytes += tile->bytes_consumed_if_allocated();
+    }
 
     // Tile is OOM.
     if (tile_bytes > bytes_left) {
@@ -476,8 +506,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);
@@ -561,7 +593,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())
@@ -610,6 +643,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;
 }
 
@@ -655,6 +689,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,
@@ -664,19 +699,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);
 }
 
@@ -684,6 +720,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);
@@ -697,6 +734,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;
 
@@ -705,6 +748,7 @@ void TileManager::OnRasterTaskCompleted(
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile->tile_version().resource_ = resource.Pass();
+    tile->tile_version().raster_flags_ = raster_flags;
   }
 
   DidFinishTileInitialization(tile.get());
@@ -790,6 +834,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>();
 }
 
@@ -817,6 +862,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);

[reveman, 2013/06/04 16:17:12]

How about low-quality when using lcd text? I don't think we should use a bit
mask unless we intend to support all combinations of it.

[vmpstr, 2013/06/04 16:59:08]

Low quality filter disables lcd text as well. I prefer it as a bitmask, since
each of the bits can be determined independently. Wdyt?

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

If they can be on/off independently but we don't support all combinations, then
you need to DCHECK that we don't end up with an invalid combination. The closer
to the source you can do that check the better and the less code we have where
invalid states can exist the better.

+
+  canvas.setDrawFilter(draw_filter.get());
+
   if (stats_instrumentation->record_rendering_stats()) {
     PicturePileImpl::RasterStats raster_stats;
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, &raster_stats);