cc: Added tile bundles

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 161 matching lines @@
       float width;
       if (*iter && iter->IsReadyToDraw()) {
         ManagedTileState::TileVersion::Mode mode =
             iter->GetTileVersionForDrawing().mode();
         if (mode == ManagedTileState::TileVersion::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
         } else if (mode == ManagedTileState::TileVersion::PICTURE_PILE_MODE) {
           color = DebugColors::PictureTileBorderColor();
           width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
-        } else if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
+        } else if (iter.priority().resolution == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
-        } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {
+        } else if (iter.priority().resolution == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
         } else if (iter->contents_scale() > contents_scale_x()) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
           color = DebugColors::ExtraLowResTileBorderColor();
           width = DebugColors::ExtraLowResTileBorderWidth(layer_tree_impl());
         }
       } else {
@@ skipping 276 matching lines @@
       pile_.get(),
       content_rect.size(),
       content_rect,
       contents_opaque() ? content_rect : gfx::Rect(),
       tiling->contents_scale(),
       id(),
       layer_tree_impl()->source_frame_number(),
       is_using_lcd_text_);
 }
 
+scoped_refptr<TileBundle> PictureLayerImpl::CreateTileBundle(
+    gfx::Rect bundle_rect) {
+  return layer_tree_impl()->tile_manager()->CreateTileBundle(bundle_rect);
+}
+
 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_)
     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;
 }
 
+bool PictureLayerImpl::IsActive() const {

[enne (OOO), 2013/11/27 01:38:05]

What did you think about my suggestion to remove these?

[vmpstr, 2013/11/27 21:09:36]

Sorry, I thought I replied to this one. I don't mind doing it, but I think that
will come at a cost of adding DidBecomePending callback. Or am I
misunderstanding something?

My comment was basically that we'll have to keep state and make sure it's up to
date, which seems like an optimization for a price of possible inconsistent
state? I don't know :P I can change it if you feel that it will be better.

[enne (OOO), 2013/11/27 22:21:15]

You could set the tiling to be pending when it becomes recycled and that would
save having the callback.

This is a wishywashy reason, but I feel like it's cleaner to have the tiling
sort of go through clear states of pending -> active -> recycled -> pending.  If
it's a client callback, you could just be like "I'm pending now" or "I'm active
now" at arbitrary points in time in a test, which is kind of not real and breaks
assumptions of how it should be used.  It's also a bit redundant.  Either the
layer tells the tiling what state it's in or the tiling asks the layer what
state it's in, but maybe not both?

+  return layer_tree_impl()->IsActiveTree();
+}
+
+bool PictureLayerImpl::IsPending() const {
+  return layer_tree_impl()->IsPendingTree();
+}
+
 gfx::Size PictureLayerImpl::CalculateTileSize(
     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 =
@@ skipping 193 matching lines @@
                                                    contents_scale_x(),
                                                    rect);
          iter;
          ++iter) {
       if (!*iter || !iter->IsReadyToDraw())
         continue;
 
       // This iteration is over the visible content rect which is potentially
       // less conservative than projecting the viewport into the layer.
       // Ignore tiles that are know to be outside the viewport.
-      if (iter->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
+      if (iter.priority().distance_to_visible_in_pixels != 0)
         continue;
 
       missing_region.Subtract(iter.geometry_rect());
       iter->MarkRequiredForActivation();
     }
   }
   DCHECK(high_res) << "There must be one high res tiling";
 
   // If these pointers are null (because no twin, no matching tiling, or the
   // simpification just below), then high res tiles will be required to fill any
@@ skipping 29 matching lines @@
         low_res, twin_low_res, contents_scale_x(), rect, &missing_region);
   }
 }
 
 bool PictureLayerImpl::MarkVisibleTilesAsRequired(
     PictureLayerTiling* tiling,
     const PictureLayerTiling* optional_twin_tiling,
     float contents_scale,
     gfx::Rect rect,
     Region* missing_region) const {
+  DCHECK(layer_tree_impl()->IsPendingTree());
+
   bool twin_had_missing_tile = false;
   for (PictureLayerTiling::CoverageIterator iter(tiling,
                                                  contents_scale,
                                                  rect);
        iter;
        ++iter) {
     Tile* tile = *iter;
     // A null tile (i.e. missing recording) can just be skipped.
     if (!tile)
       continue;
 
     // This iteration is over the visible content rect which is potentially
     // less conservative than projecting the viewport into the layer.
     // Ignore tiles that are know to be outside the viewport.
-    if (tile->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
+    if (iter.priority().distance_to_visible_in_pixels != 0)
       continue;
 
     // If the missing region doesn't cover it, this tile is fully
     // covered by acceptable tiles at other scales.
     if (!missing_region->Intersects(iter.geometry_rect()))
       continue;
 
     // If the twin tile isn't ready to draw, then this tile isn't
     // required to prevent flashing.
     if (optional_twin_tiling) {
-      Tile* twin_tile = optional_twin_tiling->TileAt(iter.i(), iter.j());
+      Tile* twin_tile =
+          optional_twin_tiling->TileAt(ACTIVE_TREE, iter.i(), iter.j());
       if (!twin_tile || !twin_tile->IsReadyToDraw()) {
         twin_had_missing_tile = true;
         continue;
       }
     }
 
     missing_region->Subtract(iter.geometry_rect());
     tile->MarkRequiredForActivation();
   }
   return twin_had_missing_tile;
@@ skipping 406 matching lines @@
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc