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..b04de337f4d7dab9e0e37e7acbc06d2e95a9ca05 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) {
@@ -306,15 +319,32 @@ void TileManager::CheckForCompletedTileUploads() {
        it != tiles_that_need_to_be_initialized_for_activation_.end();
        ++it) {
     Tile* tile = *it;
-    if (!tile->managed_state().raster_task.is_null() &&
-        !tile->tile_version().forced_upload_) {
-      if (!raster_worker_pool_->ForceUploadToComplete(
-              tile->managed_state().raster_task))
-        continue;
+    ManagedTileState& mts = tile->managed_state();
 
-      // Setting |forced_upload_| to true makes this tile ready to draw.
-      tile->tile_version().forced_upload_ = true;
-      initialized_tiles.insert(tile);
+    // Tiles that already have a resource
+    // shouldn't be required for activation.
+    DCHECK(!tile->tile_version().resource_);
+
+    ManagedTileState::TileVersionMap::iterator version_it;
+    for (version_it = mts.pending_tile_versions.begin();
+         version_it != mts.pending_tile_versions.end();
+         ++version_it) {
+      ManagedTileState::TileVersion* pending_version = version_it->second;
+      if (!pending_version->forced_upload_) {
+        if (!raster_worker_pool_->ForceUploadToComplete(
+                pending_version->raster_task_)) {
+          continue;
+        }
+
+        if (tile->tile_version().ShouldBeUpdatedBy(
+                pending_version->raster_mode_)) {
+          tile->tile_version().forced_upload_ = true;
+          tile->tile_version().resource_id_ = pending_version->resource_id_;
+          tile->tile_version().raster_mode_ = pending_version->raster_mode_;
+          initialized_tiles.insert(tile);
+          break;
+        }
+      }
     }
   }
 
@@ -393,6 +423,22 @@ void TileManager::AddRequiredTileForActivation(Tile* tile) {
   tiles_that_need_to_be_initialized_for_activation_.insert(tile);
 }
 
+TileRasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
+  DCHECK(tile);
+  DCHECK(tile->picture_pile());
+
+  TileRasterMode raster_mode = INVALID_RASTER_MODE;
+
+  if (tile->managed_state().resolution == LOW_RESOLUTION)
+    raster_mode = LOW_QUALITY_RASTER_MODE;
+  else if (!tile->picture_pile()->can_use_lcd_text())
+    raster_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
+  else
+    raster_mode = HIGH_QUALITY_RASTER_MODE;
+
+  return raster_mode;
+}
+
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
 
@@ -447,11 +493,19 @@ void TileManager::AssignGpuMemoryToTiles() {
     if (tile_version.resource_)
       tile_bytes += tile->bytes_consumed_if_allocated();
 
-    // 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())
+    TileRasterMode current_raster_mode = tile_version.raster_mode_;
+    TileRasterMode required_raster_mode = DetermineRasterMode(tile);

[reveman, 2013/06/05 14:25:13]

What if you compute new raster mode as the best of the old and the currently
desired mode? We add ManagedTileState::raster_mode which is updated as a
separate task of ManageTiles. Ideally in a DetermineRasterModeForTiles()
function.

Existing tile_version related code here and in ScheduleTasks would be the same
as before but s/tile_version/tile_versions[mts.raster_mode]/.

Wdyt?

+
+    ManagedTileState::TileVersionMap::iterator version_it =
+        mts.pending_tile_versions.find(required_raster_mode);
+
+    // If we don't have the current version, and it's not in flight
+    // then we'll have to pay to create a new task.
+    if (version_it == mts.pending_tile_versions.end() &&
+        (!tile_version.resource_ ||
+         (current_raster_mode != required_raster_mode))) {
       tile_bytes += tile->bytes_consumed_if_allocated();
+    }
 
     // Tile is OOM.
     if (tile_bytes > bytes_left) {
@@ -477,8 +531,10 @@ void TileManager::AssignGpuMemoryToTiles() {
     if (higher_priority_tile_oomed)
       continue;
 
-    if (!tile_version.resource_)
+    if (!tile_version.resource_ ||
+        (current_raster_mode != required_raster_mode)) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
+    }
 
     if (!tile_version.resource_ && tile->required_for_activation())
       AddRequiredTileForActivation(tile);
@@ -561,15 +617,31 @@ void TileManager::ScheduleTasks() {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
 
+    TileRasterMode required_raster_mode = DetermineRasterMode(tile);
+
     DCHECK(tile->tile_version().requires_resource());
-    DCHECK(!tile->tile_version().resource_);
+    DCHECK(!tile->tile_version().resource_ ||
+           (tile->tile_version().raster_mode_ != required_raster_mode));
+
+    ManagedTileState::TileVersionMap::iterator version_it =
+        mts.pending_tile_versions.find(required_raster_mode);
+
+    // Create tile version for this tile if necessary.
+    if (version_it == mts.pending_tile_versions.end()) {
+      ManagedTileState::TileVersion* new_tile_version =
+          new ManagedTileState::TileVersion;
 
-    // Create raster task for this tile if necessary.
-    if (mts.raster_task.is_null())
-      mts.raster_task = CreateRasterTask(tile);
+      new_tile_version->raster_task_ =
+          CreateRasterTask(tile, &new_tile_version->resource_id_);
+      new_tile_version->raster_mode_ = required_raster_mode;
 
-    // Finally append raster task.
-    tasks.Append(mts.raster_task);
+      mts.pending_tile_versions.insert(
+          std::make_pair(required_raster_mode, new_tile_version));
+
+      version_it = mts.pending_tile_versions.find(required_raster_mode);
+    }
+
+    tasks.Append(version_it->second->raster_task_);
   }
 
   // Schedule running of |tasks|. This replaces any previously
@@ -611,11 +683,14 @@ TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
   metadata.layer_id = tile.layer_id();
   metadata.tile_id = &tile;
   metadata.source_frame_number = tile.source_frame_number();
+  metadata.raster_mode = DetermineRasterMode(&tile);
   return metadata;
 }
 
-RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
-  TRACE_EVENT0("cc", "TileManager::CreateRasterTask");
+RasterWorkerPool::RasterTask TileManager::CreateRasterTask(
+    Tile* tile,
+    ResourceProvider::ResourceId* resource_id) {
+  TRACE_EVENT0("cc", "TileManager::CreateNewTileVersion");
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
@@ -623,7 +698,8 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
           tile->tile_version().resource_format_);
   const Resource* const_resource = resource.get();
 
-  tile->tile_version().resource_id_ = resource->id();
+  DCHECK(resource_id);
+  *resource_id = resource->id();
 
   PicturePileImpl::Analysis* analysis = new PicturePileImpl::Analysis;
 
@@ -656,6 +732,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 +742,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_mode),
       &decode_tasks);
 }
 
@@ -685,29 +763,55 @@ void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     PicturePileImpl::Analysis* analysis,
+    TileRasterMode raster_mode,
     bool was_canceled) {
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
   ManagedTileState& mts = tile->managed_state();
-  DCHECK(!mts.raster_task.is_null());
-  mts.raster_task.Reset();
+  ManagedTileState::TileVersionMap::iterator version_it =
+      mts.pending_tile_versions.find(raster_mode);
+
+  DCHECK(version_it != mts.pending_tile_versions.end());
+
+  scoped_ptr<ManagedTileState::TileVersion> new_tile_version(
+      version_it->second);
+  mts.pending_tile_versions.erase(version_it);
+
+  new_tile_version->raster_task_.Reset();
+  new_tile_version->forced_upload_ = false;
+  new_tile_version->resource_ = resource.Pass();
 
   if (was_canceled) {
-    resource_pool_->ReleaseResource(resource.Pass());
+    resource_pool_->ReleaseResource(new_tile_version->resource_.Pass());
     return;
   }
 
+  // Release the current resource in preparation of update.
+  if (tile->tile_version().resource_ &&
+      tile->tile_version().ShouldBeUpdatedBy(raster_mode)) {
+    resource_pool_->ReleaseResource(tile->tile_version().resource_.Pass());
+    DCHECK(tile->tile_version().raster_mode_ != raster_mode);
+    tile->tile_version().raster_mode_ = INVALID_RASTER_MODE;
+    tile->tile_version().forced_upload_ = false;
+  }
+
   mts.picture_pile_analysis = *analysis;
   mts.picture_pile_analyzed = true;
 
+  // If the tile is solid color, mark it as such
+  // Otherwise, only update the resource if the tile doesn't have one.
+  // This would have been cleared above, if this version is better than
+  // the existing one.
   if (analysis->is_solid_color) {
     tile->tile_version().set_solid_color(analysis->solid_color);
-    resource_pool_->ReleaseResource(resource.Pass());
-  } else {
-    tile->tile_version().resource_ = resource.Pass();
+  } else if (!tile->tile_version().resource_) {
+    new_tile_version->PushPropertiesTo(&tile->tile_version());
   }
 
+  if (new_tile_version->resource_)
+    resource_pool_->ReleaseResource(new_tile_version->resource_.Pass());
+
   DidFinishTileInitialization(tile.get());
 }
 
@@ -791,6 +895,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_mode", raster_mode);
   return res.PassAs<base::Value>();
 }
 
@@ -818,6 +923,23 @@ bool TileManager::RunRasterTask(
 
   SkCanvas canvas(device);
 
+  skia::RefPtr<SkDrawFilter> draw_filter;
+  switch (metadata.raster_mode) {
+    case LOW_QUALITY_RASTER_MODE:
+      draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
+      break;
+    case HIGH_QUALITY_NO_LCD_RASTER_MODE:
+      draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
+      break;
+    case HIGH_QUALITY_RASTER_MODE:
+      break;
+    case INVALID_RASTER_MODE:
+    default:
+      NOTREACHED();
+  }
+
+  canvas.setDrawFilter(draw_filter.get());
+
   if (stats_instrumentation->record_rendering_stats()) {
     PicturePileImpl::RasterStats raster_stats;
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, &raster_stats);