cc: Low quality support for low res tiles

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 <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #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"
 
 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) {
   // The amount of time for which we want to have prepainting coverage.
   const float kPrepaintingWindowTimeSeconds = 1.0f;
   const float kBackflingGuardDistancePixels = 314.0f;
 
   if (prio.time_to_visible_in_seconds == 0)
     return NOW_BIN;
 
@@ skipping 350 matching lines @@
 }
 
 void TileManager::AddRequiredTileForActivation(Tile* tile) {
   DCHECK(std::find(tiles_that_need_to_be_initialized_for_activation_.begin(),
                    tiles_that_need_to_be_initialized_for_activation_.end(),
                    tile) ==
          tiles_that_need_to_be_initialized_for_activation_.end());
   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");
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   tiles_that_need_to_be_rasterized_.clear();
   tiles_that_need_to_be_initialized_for_activation_.clear();
 
   size_t bytes_releasable = 0;
   for (TileVector::const_iterator it = tiles_.begin();
@@ skipping 34 matching lines @@
       FreeResourcesForTile(tile);
       continue;
     }
 
     size_t tile_bytes = 0;
 
     // It costs to maintain a resource.
     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) {
       tile->tile_version().set_rasterize_on_demand();
       if (mts.tree_bin[PENDING_TREE] == NOW_BIN) {
         tiles_requiring_memory_but_oomed.push_back(tile);
         bytes_oom_in_now_bin_on_pending_tree += tile_bytes;
       }
       FreeResourcesForTile(tile);
       higher_priority_tile_oomed = true;
       continue;
     }
 
     tile_version.set_use_resource();
     bytes_left -= tile_bytes;
 
     // Tile shouldn't be rasterized if we've failed to assign
     // gpu memory to a higher priority tile. This is important for
     // two reasons:
     // 1. Tile size should not impact raster priority.
     // 2. Tile with unreleasable memory could otherwise incorrectly
     //    be added as it's not affected by |bytes_allocatable|.
     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);
   }
 
   // In OOM situation, we iterate tiles_, remove the memory for active tree
   // and not the now bin. And give them to bytes_oom_in_now_bin_on_pending_tree
   if (!tiles_requiring_memory_but_oomed.empty()) {
     size_t bytes_freed = 0;
     for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
@@ skipping 63 matching lines @@
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin();
        it != tiles_that_need_to_be_rasterized_.end();
        ++it) {
     Tile* tile = *it;
     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())
       mts.raster_task = CreateRasterTask(tile);
 
     // Finally append raster task.
     tasks.Append(mts.raster_task);
   }
 
   // Schedule running of |tasks|. This replaces any previously
@@ skipping 28 matching lines @@
 TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
     const Tile& tile) const {
   RasterTaskMetadata metadata;
   const ManagedTileState& mts = tile.managed_state();
   metadata.is_tile_in_pending_tree_now_bin =
       mts.tree_bin[PENDING_TREE] == NOW_BIN;
   metadata.tile_resolution = mts.resolution;
   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;
 }
 
 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::CreateRasterTask");
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
           tile->tile_size_.size(),
           tile->tile_version().resource_format_);
@@ skipping 25 matching lines @@
       continue;
     }
 
     // Create and append new image decode task for this pixel ref.
     RasterWorkerPool::Task decode_task = CreateImageDecodeTask(
         tile, pixel_ref);
     decode_tasks.Insert(decode_task);
     pending_decode_tasks_[id] = decode_task;
   }
 
+  RasterTaskMetadata metadata = GetRasterTaskMetadata(*tile);
   return RasterWorkerPool::RasterTask(
       tile->picture_pile(),
       const_resource,
       base::Bind(&TileManager::RunAnalyzeAndRasterTask,
                  base::Bind(&TileManager::RunAnalyzeTask,
                             analysis,
                             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);
 }
 
 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);
 
   ManagedTileState& mts = tile->managed_state();
   DCHECK(!mts.raster_task.is_null());
   mts.raster_task.Reset();
 
   if (was_canceled) {
     resource_pool_->ReleaseResource(resource.Pass());
     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;
 
   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();
+    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());
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
   if (tile->required_for_activation()) {
     // It's possible that a tile required for activation is not in this list
@@ skipping 65 matching lines @@
   analysis->is_solid_color &= use_color_estimator;
 }
 
 scoped_ptr<base::Value> TileManager::RasterTaskMetadata::AsValue() const {
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
   res->Set("tile_id", TracedValue::CreateIDRef(tile_id).release());
   res->SetBoolean("is_tile_in_pending_tree_now_bin",
                   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>();
 }
 
 // static
 bool TileManager::RunRasterTask(
     PicturePileImpl::Analysis* analysis,
     gfx::Rect rect,
     float contents_scale,
     const RasterTaskMetadata& metadata,
     RenderingStatsInstrumentation* stats_instrumentation,
     SkDevice* device,
     PicturePileImpl* picture_pile) {
   TRACE_EVENT1(
       "cc", "TileManager::RunRasterTask",
       "metadata", TracedValue::FromValue(metadata.AsValue().release()));
   devtools_instrumentation::ScopedLayerTask raster_task(
       devtools_instrumentation::kRasterTask, metadata.layer_id);
 
   DCHECK(picture_pile);
   DCHECK(analysis);
   DCHECK(device);
 
   if (analysis->is_solid_color)
     return false;
 
   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);
     stats_instrumentation->AddRaster(
         raster_stats.total_rasterize_time,
         raster_stats.best_rasterize_time,
         raster_stats.total_pixels_rasterized,
         metadata.is_tile_in_pending_tree_now_bin);
 
     HISTOGRAM_CUSTOM_COUNTS(
         "Renderer4.PictureRasterTimeUS",
         raster_stats.total_rasterize_time.InMicroseconds(),
         0,
         100000,
         100);
   } else {
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, NULL);
   }
 
   return true;
 }
 
 }  // namespace cc