cc: Let skia veto gpu rasterization.

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),
-      has_gpu_rasterization_hint_(false),
       should_use_low_res_tiling_(tree_impl->settings().create_low_res_tiling),
+      use_gpu_rasterization_(false),
       layer_needs_to_register_itself_(true) {}
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (!layer_needs_to_register_itself_)
     layer_tree_impl()->tile_manager()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
 }
@@ skipping 20 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_);
+  layer_impl->use_gpu_rasterization_ = use_gpu_rasterization_;
 
   // 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 362 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::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();
-}
+void PictureLayerImpl::SetUseGpuRasterization(bool use_gpu) {
+  if (use_gpu_rasterization_ == use_gpu)
+    return;
 
-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;
+  use_gpu_rasterization_ = use_gpu;
+  RemoveAllTilings();
 }
 
 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;
@@ skipping 859 matching lines @@
   DCHECK(*this);
 
   IteratorType index = stages_[current_stage_].iterator_type;
   DCHECK(iterators_[index]);
   DCHECK(iterators_[index].get_type() == stages_[current_stage_].tile_type);
 
   return *iterators_[index];
 }
 
 }  // namespace cc