cc: Trigger GPU rasterization based on a per-layer hint

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 36 matching lines @@
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_was_animating_(false),
       is_using_lcd_text_(tree_impl->settings().can_use_lcd_text),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false),
-      should_use_gpu_rasterization_(tree_impl->settings().gpu_rasterization) {}
+      has_gpu_rasterization_hint_(false) {}
 
 PictureLayerImpl::~PictureLayerImpl() {}
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
 }
 
 scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return PictureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
@@ skipping 16 matching lines @@
 
   LayerImpl::PushPropertiesTo(base_layer);
 
   // When the pending tree pushes to the active tree, the pending twin
   // disappears.
   layer_impl->twin_layer_ = NULL;
   twin_layer_ = NULL;
 
   layer_impl->SetIsMask(is_mask_);
   layer_impl->pile_ = pile_;
+  layer_impl->SetHasGpuRasterizationHint(has_gpu_rasterization_hint_);
 
   // Tilings would be expensive to push, so we swap.  This optimization requires
   // an extra invalidation in SyncFromActiveLayer.
   layer_impl->tilings_.swap(tilings_);
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
     tilings_->SetClient(this);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
@@ skipping 338 matching lines @@
   *contents_scale_x = max_contents_scale;
   *contents_scale_y = max_contents_scale;
   *content_bounds = gfx::ToCeiledSize(
       gfx::ScaleSize(bounds(), max_contents_scale, max_contents_scale));
 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return pile_->GetFlattenedPicture();
 }
 
-void PictureLayerImpl::SetShouldUseGpuRasterization(
-    bool should_use_gpu_rasterization) {
-  if (should_use_gpu_rasterization != should_use_gpu_rasterization_) {
-    should_use_gpu_rasterization_ = should_use_gpu_rasterization;
+void PictureLayerImpl::SetHasGpuRasterizationHint(bool has_hint) {
+  bool old_should_use_gpu_rasterization = ShouldUseGpuRasterization();
+  has_gpu_rasterization_hint_ = has_hint;
+  if (ShouldUseGpuRasterization() != old_should_use_gpu_rasterization)
     RemoveAllTilings();
-  } else {
-    should_use_gpu_rasterization_ = should_use_gpu_rasterization;
+}
+
+bool PictureLayerImpl::ShouldUseGpuRasterization() const {
+  switch (layer_tree_impl()->settings().rasterization_site) {
+    case LayerTreeSettings::CpuRasterization:
+      return false;
+    case LayerTreeSettings::HybridRasterization:
+      return has_gpu_rasterization_hint_;
+    case LayerTreeSettings::GpuRasterization:
+      return true;
   }
+  NOTREACHED();
+  return false;
 }
 
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
                                                const gfx::Rect& content_rect) {
   if (!pile_->CanRaster(tiling->contents_scale(), content_rect))
     return scoped_refptr<Tile>();
 
   int flags = 0;
   if (is_using_lcd_text_)
     flags |= Tile::USE_LCD_TEXT;
-  if (should_use_gpu_rasterization())
+  if (ShouldUseGpuRasterization())
     flags |= Tile::USE_GPU_RASTERIZATION;
   return layer_tree_impl()->tile_manager()->CreateTile(
       pile_.get(),
       content_rect.size(),
       content_rect,
       contents_opaque() ? content_rect : gfx::Rect(),
       tiling->contents_scale(),
       id(),
       layer_tree_impl()->source_frame_number(),
       flags);
 }
 
 void PictureLayerImpl::UpdatePile(Tile* tile) {
   tile->set_picture_pile(pile_);
 }
 
 const Region* PictureLayerImpl::GetInvalidation() {
   return &invalidation_;
 }
 
 const PictureLayerTiling* PictureLayerImpl::GetTwinTiling(
     const PictureLayerTiling* tiling) const {
 
-  if (!twin_layer_ || twin_layer_->should_use_gpu_rasterization() !=
-      should_use_gpu_rasterization())
+  if (!twin_layer_ ||
+      twin_layer_->ShouldUseGpuRasterization() != ShouldUseGpuRasterization())
     return NULL;
   for (size_t i = 0; i < twin_layer_->tilings_->num_tilings(); ++i)
     if (twin_layer_->tilings_->tiling_at(i)->contents_scale() ==
         tiling->contents_scale())
       return twin_layer_->tilings_->tiling_at(i);
   return NULL;
 }
 
 size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
   return layer_tree_impl()->settings().max_tiles_for_interest_area;
@@ skipping 328 matching lines @@
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilingWithScale(contents_scale)) <<
       "contents_scale: " << contents_scale;
 
   PictureLayerTiling* tiling = tilings_->AddTiling(contents_scale);
 
   const Region& recorded = pile_->recorded_region();
   DCHECK(!recorded.IsEmpty());
 
-  if (twin_layer_ && twin_layer_->should_use_gpu_rasterization() ==
-      should_use_gpu_rasterization())
+  if (twin_layer_ &&
+      twin_layer_->ShouldUseGpuRasterization() == ShouldUseGpuRasterization())
     twin_layer_->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->contents_scale() == contents_scale) {
       tilings_->Remove(tiling);
       break;
     }
   }
   if (tilings_->num_tilings() == 0)
     ResetRasterScale();
   SanityCheckTilingState();
 }
 
 void PictureLayerImpl::RemoveAllTilings() {
-  tilings_->RemoveAllTilings();
+  if (tilings_)
+    tilings_->RemoveAllTilings();
   // If there are no tilings, then raster scales are no longer meaningful.
   ResetRasterScale();
 }
 
 namespace {
 
 inline float PositiveRatio(float float1, float float2) {
   DCHECK_GT(float1, 0);
   DCHECK_GT(float2, 0);
   return float1 > float2 ? float1 / float2 : float2 / float1;
@@ skipping 334 matching lines @@
     scoped_ptr<base::DictionaryValue> tile_data(new base::DictionaryValue);
     tile_data->Set("geometry_rect",
                    MathUtil::AsValue(iter.geometry_rect()).release());
     if (*iter)
       tile_data->Set("tile", TracedValue::CreateIDRef(*iter).release());
 
     coverage_tiles->Append(tile_data.release());
   }
   state->Set("coverage_tiles", coverage_tiles.release());
   state->SetBoolean("is_using_lcd_text", is_using_lcd_text_);
+  state->SetBoolean("using_gpu_rasterization", ShouldUseGpuRasterization());
 }
 
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc