Paint low-res tiles without expensive filters.

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/platform_color.h"
 #include "cc/raster_worker_pool.h"
 #include "cc/resource_pool.h"
 #include "cc/tile.h"
+#include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace cc {
 
 namespace {
 
 // If we raster too fast we become upload bound, and pending
 // uploads consume memory. For maximum upload throughput, we would
 // want to allow for upload_throughput * pipeline_time of pending
 // uploads, after which we are just wasting memory. Since we don't
@@ skipping 37 matching lines @@
   return EVENTUALLY_BIN;
 }
 
 std::string ValueToString(scoped_ptr<base::Value> value)
 {
   std::string str;
   base::JSONWriter::Write(value.get(), &str);
   return str;
 }
 
+
 }  // namespace
 
 scoped_ptr<base::Value> TileManagerBinAsValue(TileManagerBin bin) {
   switch (bin) {
   case NOW_BIN:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "NOW_BIN"));
   case SOON_BIN:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "SOON_BIN"));
@@ skipping 572 matching lines @@
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
       base::Bind(&TileManager::PerformRaster,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
                  tile->contents_scale(),
-                 use_cheapness_estimator_),
+                 use_cheapness_estimator_,
+                 ShouldSimplifyPaint(tile.get())),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
 }
 
 void TileManager::PerformOneRaster(Tile* tile) {
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
   PerformRaster(resource_pool_->resource_provider()->mapPixelBuffer(
                     resource_id),
                 tile->content_rect_,
                 tile->contents_scale(),
                 use_cheapness_estimator_,
+                ShouldSimplifyPaint(tile),
                 tile->picture_pile(),
                 &rendering_stats_);
 
   OnRasterCompleted(tile, resource.Pass(), manage_tiles_call_count_);
 }
 
 void TileManager::OnRasterCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
@@ skipping 85 matching lines @@
   ++raster_state_count_[mts.raster_state][tree][bin];
 
   mts.tree_bin[tree] = bin;
 }
 
 // static
 void TileManager::PerformRaster(uint8* buffer,
                                 const gfx::Rect& rect,
                                 float contents_scale,
                                 bool use_cheapness_estimator,
+                                bool simplify_paint,
                                 PicturePileImpl* picture_pile,
                                 RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::PerformRaster");
   DCHECK(picture_pile);
   DCHECK(buffer);
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
 
   base::TimeTicks begin_time;
   if (stats)
     begin_time = base::TimeTicks::Now();
 
+  // FIXME: PerformRaster is a static function, so we can't just create
+  // one in the constructor and reuse it. But the object is refcounted
+  // so may not be happy living on the stack. How do we get rid of this
+  // new?

[Sami, 2013/02/08 13:44:01]

You could create the simplifier as a member of TileManager and pass the
reference to this function.

+  if (simplify_paint)
+    canvas.setDrawFilter(new skia::PaintSimplifier);
+
   int64 total_pixels_rasterized = 0;
   picture_pile->Raster(&canvas, rect, contents_scale,
                        &total_pixels_rasterized);
 
   if (stats) {
     stats->totalPixelsRasterized += total_pixels_rasterized;
 
     base::TimeTicks end_time = base::TimeTicks::Now();
     base::TimeDelta duration = end_time - begin_time;
     stats->totalRasterizeTime += duration;
@@ skipping 31 matching lines @@
   if (stats)
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
+// Needs to be a member of TileManager to access Tile::managed_state()
+bool TileManager::ShouldSimplifyPaint(Tile* tile) {
+  // FIXME: tree_priority can remain SMOOTHNESS_TAKES_PRIORITY an arbitrary
+  // length of time after a fling ends. resolution can be LOW_RESOLUTION
+  // at times other than mid-fling. The two only seem to be true
+  // together during flings & pinch-zooms.
+  return
+    GlobalState().tree_priority == SMOOTHNESS_TAKES_PRIORITY &&
+    tile->managed_state().resolution == LOW_RESOLUTION;
+}
+
 }  // namespace cc