cc: Move gpu rasterization flag from LayerImpl to LayerTreeImpl.

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 45 matching lines @@
       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_is_fixed_(false),
       was_animating_transform_to_screen_(false),
       is_using_lcd_text_(tree_impl->settings().can_use_lcd_text),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(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 21 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->use_gpu_rasterization_ = use_gpu_rasterization_;
 
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
 
   // Ensure that we don't have any tiles that are out of date.
   if (tilings_)
     tilings_->RemoveTilesInRegion(invalidation_);
 
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
@@ skipping 397 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::SetUseGpuRasterization(bool use_gpu) {
-  if (use_gpu_rasterization_ == use_gpu)
-    return;
-
-  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;
-  if (ShouldUseGpuRasterization())
+  if (UseGpuRasterization())
     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_->ShouldUseGpuRasterization() != ShouldUseGpuRasterization())
+      twin_layer_->UseGpuRasterization() != UseGpuRasterization())
     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;
 }
 
 float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
-  float skewport_target_time_in_frames = ShouldUseGpuRasterization()
+  float skewport_target_time_in_frames = UseGpuRasterization()
                                              ? kGpuSkewportTargetTimeInFrames
                                              : kCpuSkewportTargetTimeInFrames;
   return skewport_target_time_in_frames *
          layer_tree_impl()->begin_impl_frame_interval().InSecondsF() *
          layer_tree_impl()->settings().skewport_target_time_multiplier;
 }
 
 int PictureLayerImpl::GetSkewportExtrapolationLimitInContentPixels() const {
   return layer_tree_impl()
       ->settings()
       .skewport_extrapolation_limit_in_content_pixels;
 }
 
 gfx::Size PictureLayerImpl::CalculateTileSize(
     const gfx::Size& content_bounds) const {
   if (is_mask_) {
     int max_size = layer_tree_impl()->MaxTextureSize();
     return gfx::Size(
         std::min(max_size, content_bounds.width()),
         std::min(max_size, content_bounds.height()));
   }
 
   int max_texture_size =
       layer_tree_impl()->resource_provider()->max_texture_size();
 
   gfx::Size default_tile_size = layer_tree_impl()->settings().default_tile_size;
-  if (ShouldUseGpuRasterization()) {
+  if (UseGpuRasterization()) {
     // TODO(ernstm) crbug.com/365877: We need a unified way to override the
     // default-tile-size.
     default_tile_size =
         gfx::Size(layer_tree_impl()->device_viewport_size().width(),
                   layer_tree_impl()->device_viewport_size().height() / 4);
   }
   default_tile_size.SetToMin(gfx::Size(max_texture_size, max_texture_size));
 
   gfx::Size max_untiled_content_size =
       layer_tree_impl()->settings().max_untiled_layer_size;
@@ skipping 295 matching lines @@
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilingWithScale(contents_scale)) <<
       "contents_scale: " << contents_scale;
 
   PictureLayerTiling* tiling = tilings_->AddTiling(contents_scale);
 
   DCHECK(pile_->HasRecordings());
 
   if (twin_layer_ &&
-      twin_layer_->ShouldUseGpuRasterization() == ShouldUseGpuRasterization())
+      twin_layer_->UseGpuRasterization() == UseGpuRasterization())
     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);
@@ skipping 97 matching lines @@
 
   SanityCheckTilingState();
 }
 
 bool PictureLayerImpl::ShouldAdjustRasterScale(
     bool animating_transform_to_screen) const {
   if (was_animating_transform_to_screen_ != animating_transform_to_screen)
     return true;
 
   if (animating_transform_to_screen &&
-      raster_contents_scale_ != ideal_contents_scale_ &&
-      ShouldUseGpuRasterization())
+      raster_contents_scale_ != ideal_contents_scale_ && UseGpuRasterization())
     return true;
 
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (is_pinching && raster_page_scale_) {
     // We change our raster scale when it is:
     // - Higher than ideal (need a lower-res tiling available)
     // - Too far from ideal (need a higher-res tiling available)
     float ratio = ideal_page_scale_ / raster_page_scale_;
     if (raster_page_scale_ > ideal_page_scale_ ||
         ratio > kMaxScaleRatioDuringPinch)
@@ skipping 79 matching lines @@
     raster_page_scale_ =
         raster_contents_scale_ / raster_device_scale_ / raster_source_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
 
   // If we're not re-rasterizing during animation, rasterize at the maximum
   // scale that will occur during the animation, if the maximum scale is
   // known.
-  if (animating_transform_to_screen && !ShouldUseGpuRasterization()) {
+  if (animating_transform_to_screen && !UseGpuRasterization()) {
     if (maximum_animation_contents_scale > 0.f) {
       raster_contents_scale_ =
           std::max(raster_contents_scale_, maximum_animation_contents_scale);
     } else {
       raster_contents_scale_ =
           std::max(raster_contents_scale_,
                    1.f * ideal_page_scale_ * ideal_device_scale_);
     }
   }
 
@@ skipping 169 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());
+  state->SetBoolean("using_gpu_rasterization", UseGpuRasterization());
 }
 
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 WhichTree PictureLayerImpl::GetTree() const {
   return layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 }
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
+bool PictureLayerImpl::UseGpuRasterization() const {
+  return layer_tree_impl()->use_gpu_rasterization();
+}
+
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator()
     : layer_(NULL) {}
 
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator(
     PictureLayerImpl* layer,
     bool prioritize_low_res)
     : layer_(layer), current_stage_(0) {
   DCHECK(layer_);
   if (!layer_->tilings_ || !layer_->tilings_->num_tilings()) {
     current_stage_ = arraysize(stages_);
@@ skipping 203 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc