cc: Add tiling raster tile iterators.

cc/resources/picture_layer_tiling.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/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
+#include "cc/resources/tile.h"
+#include "cc/resources/tile_priority.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/safe_integer_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     const gfx::Size& layer_bounds,
@@ skipping 34 matching lines @@
 }
 
 gfx::Rect PictureLayerTiling::ContentRect() const {
   return gfx::Rect(tiling_data_.total_size());
 }
 
 gfx::SizeF PictureLayerTiling::ContentSizeF() const {
   return gfx::ScaleSize(layer_bounds_, contents_scale_);
 }
 
-Tile* PictureLayerTiling::TileAt(int i, int j) const {
-  TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
-  if (iter == tiles_.end())
-    return NULL;
-  return iter->second.get();
-}
-
 void PictureLayerTiling::CreateTile(int i,
                                     int j,
                                     const PictureLayerTiling* twin_tiling) {
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
 
   gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
   gfx::Rect tile_rect = paint_rect;
   tile_rect.set_size(tiling_data_.max_texture_size());
 
@@ skipping 339 matching lines @@
                                        ContentRect(),
                                        &expansion_cache_);
 
   DCHECK(eventually_rect.IsEmpty() || ContentRect().Contains(eventually_rect));
 
   SetLiveTilesRect(eventually_rect);
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
-  // Assign now priority to all visible tiles.
+  current_skewport_ = skewport;
+  current_eventually_rect_ = eventually_rect;
+  current_visible_rect_in_content_space_ = visible_rect_in_content_space;
+
   TilePriority now_priority(resolution_, TilePriority::NOW, 0);
-  for (TilingData::Iterator iter(&tiling_data_, visible_rect_in_content_space);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    Tile* tile = find->second.get();
-
-    tile->SetPriority(tree, now_priority);
-  }
-
-  // Assign soon priority to all tiles in the skewport that are not visible.
   float content_to_screen_scale =
       1.0f / (contents_scale_ * layer_contents_scale);
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, skewport, visible_rect_in_content_space);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
+
+  for (TilingRasterTileIterator it(this); it; ++it) {
+    Tile* tile = *it;
+    if (it.get_type() == TilingRasterTileIterator::VISIBLE) {
+      tile->SetPriority(tree, now_priority);
       continue;
-    Tile* tile = find->second.get();
+    }
 
-    gfx::Rect tile_bounds =
-        tiling_data_.TileBounds(iter.index_x(), iter.index_y());
+    TilePriority::PriorityBin bin =
+        (it.get_type() == TilingRasterTileIterator::SKEWPORT)
+            ? TilePriority::SOON
+            : TilePriority::EVENTUALLY;
+
+    gfx::Rect tile_bounds = it.TileBounds();
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
 
-    TilePriority priority(resolution_, TilePriority::SOON, distance_to_visible);
+    TilePriority priority(resolution_, bin, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
-
-  // Assign eventually priority to all tiles in the eventually rect that are not
-  // in the skewport.
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, eventually_rect, skewport);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    Tile* tile = find->second.get();
-
-    gfx::Rect tile_bounds =
-        tiling_data_.TileBounds(iter.index_x(), iter.index_y());
-
-    float distance_to_visible =
-        visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
-        content_to_screen_scale;
-    TilePriority priority(
-        resolution_, TilePriority::EVENTUALLY, distance_to_visible);
-    tile->SetPriority(tree, priority);
-  }
+  last_update_tree_ = tree;
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          ContentRect().Contains(new_live_tiles_rect));
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
@@ skipping 49 matching lines @@
     client_->UpdatePile(it->second.get());
   }
 }
 
 void PictureLayerTiling::UpdateTilesToCurrentPile() {
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     client_->UpdatePile(it->second.get());
   }
 }
 
+size_t PictureLayerTiling::RequiredGPUMemoryInBytes() const {
+  size_t amount = 0;
+  for (TilingData::Iterator iter(&tiling_data_,
+                                 last_visible_rect_in_content_space_);
+       iter;
+       ++iter) {
+    TileMap::const_iterator find = tiles_.find(iter.index());
+    if (find == tiles_.end())
+      continue;
+    Tile* tile = find->second.get();
+    amount += tile->GPUMemoryUsageInBytes();
+  }
+  return amount;
+}
+
 scoped_ptr<base::Value> PictureLayerTiling::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   state->Set("content_bounds",
              MathUtil::AsValue(ContentRect().size()).release());
   return state.PassAs<base::Value>();
 }
 
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
@@ skipping 147 matching lines @@
     if (delta < event.distance)
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
+PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
+    : tiling_(NULL), current_tile_(NULL) {}
+
+PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
+    PictureLayerTiling* tiling)
+    : tiling_(tiling),
+      type_(VISIBLE),
+      current_tile_(NULL),
+      visible_iterator_(&tiling->tiling_data_,
+                        tiling->current_visible_rect_in_content_space_),
+      spiral_iterator_(&tiling->tiling_data_,
+                       tiling->current_skewport_,
+                       tiling->current_visible_rect_in_content_space_,
+                       tiling->current_visible_rect_in_content_space_) {
+  if (!visible_iterator_) {
+    AdvancePhase();
+    return;
+  }
+
+  current_tile_ =
+      tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
+  if (!current_tile_)
+    ++(*this);
+}
+
+PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
+
+void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
+  DCHECK_LT(type_, EVENTUALLY);
+
+  do {
+    type_ = static_cast<Type>(type_ + 1);
+    if (type_ == EVENTUALLY) {
+      spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+          &tiling_->tiling_data_,
+          tiling_->current_eventually_rect_,
+          tiling_->current_skewport_,
+          tiling_->current_visible_rect_in_content_space_);
+    }
+
+    while (spiral_iterator_) {
+      current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(),
+                                      spiral_iterator_.index_y());
+      if (current_tile_)
+        break;
+      ++spiral_iterator_;
+    }
+
+    if (!spiral_iterator_ && type_ == EVENTUALLY)
+      break;
+  } while (!spiral_iterator_);
+}
+
+PictureLayerTiling::TilingRasterTileIterator&
+PictureLayerTiling::TilingRasterTileIterator::
+operator++() {

[epennerAtGoogle, 2014/03/05 00:16:03]

General question regarding final design: Is this eventually going to be the only
place where we set the tile's priority?  It seems like we only need it at this
point.

[vmpstr, 2014/03/05 00:37:21]

Yeah, the priority will be set lazily. I think here is the best spot. Possibly
in the layer/tile manager version of these iterators as well, but I'll have to
see what makes it look cleanest. 

+  current_tile_ = NULL;
+  while (!current_tile_) {
+    std::pair<int, int> next_index;
+    switch (type_) {
+      case VISIBLE:
+        ++visible_iterator_;
+        if (!visible_iterator_) {
+          AdvancePhase();
+          return *this;
+        }
+        next_index = visible_iterator_.index();
+        break;
+      case SKEWPORT:
+        ++spiral_iterator_;
+        if (!spiral_iterator_) {
+          AdvancePhase();
+          return *this;
+        }
+        next_index = spiral_iterator_.index();
+        break;
+      case EVENTUALLY:
+        ++spiral_iterator_;
+        if (!spiral_iterator_)
+          return *this;
+        next_index = spiral_iterator_.index();
+        break;
+    }
+    current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
+  }
+  return *this;
+}
+
 }  // namespace cc