cc: Skip analysis for narrow layers.

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 <limits>
 #include <string>
 
@@ skipping 14 matching lines @@
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
+// Minimum width/height of a pile that would require analysis for tiles.
+const int kMinSizeToAnalyze = 256;

[alokp, 2014/03/27 05:20:45]

kMinLengthToAnalyze?

[vmpstr, 2014/03/27 17:02:53]

Done.

+
 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;
   }
@@ skipping 1111 matching lines @@
         CreateImageDecodeTask(tile, pixel_ref);
     decode_tasks.push_back(decode_task);
     existing_pixel_refs[id] = decode_task;
   }
 
   // We analyze picture before rasterization to detect solid-color tiles.
   // If the tile is detected as such there is no need to raster or upload.
   // It is drawn directly as a solid-color quad saving raster and upload cost.
   // The analysis step is however expensive and is not justified when doing
   // gpu rasterization where there is no upload.
-  bool analyze_picture = !tile->use_gpu_rasterization();
+  //
+  // Additionally, we do not want to do the analysis if the layer that produced
+  // this tile is narrow, since more likely than not the tile would not be

[alokp, 2014/03/27 05:20:45]

I do not get the connection between the tile being narrow and solid. Could you
elaborate this a bit here?

[vmpstr, 2014/03/27 17:02:53]

It definitely doesn't mean that it's not solid, but I think we want to try a
heuristic that just assumes they are not. The example is a page in the bug that
has a lot of small layers, which means we spent all that extra time analyzing
it.

For the majority of the cases (1 root layer, 3 scrollbar layers), this should do
the right thing...

Did you want me to add a more elaborate comment here, or is your concern more
with the whole idea behind this?

[alokp, 2014/03/27 17:45:16]

I understand that it is just a heuristic and I am fine with it. I just wanted a
comment about the justifications for that heuristic.

+  // solid.
+  gfx::Size pile_size = tile->picture_pile()->size();
+  bool analyze_picture =
+      !tile->use_gpu_rasterization() &&
+      std::min(pile_size.width(), pile_size.height()) >= kMinSizeToAnalyze;
 
   return make_scoped_refptr(new RasterWorkerPoolTaskImpl(
       const_resource,
       tile->picture_pile(),
       tile->content_rect(),
       tile->contents_scale(),
       mts.raster_mode,
       mts.resolution,
       tile->layer_id(),
       static_cast<const void*>(tile),
@@ skipping 153 matching lines @@
     }
   }
 }
 
 TileManager::PairedPictureLayer::PairedPictureLayer()
     : active_layer(NULL), pending_layer(NULL) {}
 
 TileManager::PairedPictureLayer::~PairedPictureLayer() {}
 
 }  // namespace cc