cc: Implement tile iteration order based on pyramid sequence. [old]

cc/base/tiling_data.cc

 // Copyright 2010 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/base/tiling_data.h"
 
 #include <algorithm>
 
+#include "base/command_line.h"
+#include "cc/base/switches.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/vector2d.h"
 
 namespace cc {
 
 namespace {
 // IndexRect which is at left top corner of the positive quadrant.
 const IndexRect kNonPositiveQuadrantIndexRect(-1, -1, -1, -1);
 }
@@ skipping 66 matching lines @@
 int TilingData::TileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
   DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
   int y = (src_position - border_texels_) /
       (max_texture_size_.height() - 2 * border_texels_);
   return std::min(std::max(y, 0), num_tiles_y_ - 1);
 }
 
+int TilingData::TileAbsoluteXIndexFromSrcCoord(int src_position) const {
+  int inner_tile_width = max_texture_size_.width() - 2 * border_texels_;
+  if (inner_tile_width <= 0)
+    return 0;
+
+  int max_width = inner_tile_width * num_tiles_x_ + 2 * border_texels_;
+  if (src_position >= 0 && src_position < max_width)
+    return TileXIndexFromSrcCoord(src_position);
+
+  if (src_position >= max_width)
+    return num_tiles_x_ + (src_position - max_width) / inner_tile_width;
+
+  return (src_position + 1) / inner_tile_width - 1;
+}
+
+int TilingData::TileAbsoluteYIndexFromSrcCoord(int src_position) const {
+  int inner_tile_height = max_texture_size_.height() - 2 * border_texels_;
+  if (inner_tile_height <= 0)
+    return 0;
+
+  int max_height = inner_tile_height * num_tiles_y_ + 2 * border_texels_;
+  if (src_position >= 0 && src_position < max_height)
+    return TileYIndexFromSrcCoord(src_position);
+
+  if (src_position >= max_height)
+    return num_tiles_y_ + (src_position - max_height) / inner_tile_height;
+
+  return (src_position + 1) / inner_tile_height - 1;
+}
+
 int TilingData::FirstBorderTileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
   DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
   int inner_tile_size = max_texture_size_.width() - 2 * border_texels_;
   int x = (src_position - 2 * border_texels_) / inner_tile_size;
   return std::min(std::max(x, 0), num_tiles_x_ - 1);
 }
 
@@ skipping 64 matching lines @@
     around_bottom = -1;
   } else if (bottom_src_coord >= tiling_size().height()) {
     around_bottom = num_tiles_y();
   } else {
     around_bottom = TileYIndexFromSrcCoord(bottom_src_coord);
   }
 
   return IndexRect(around_left, around_right, around_top, around_bottom);
 }
 
+IndexRect TilingData::TileAroundAbsoluteIndexRect(
+    const gfx::Rect& center_rect) const {
+  if (center_rect.IsEmpty()) {
+    // Default around rect is assumed to be at top-left corner of tile at
+    // (0, 0).
+    return IndexRect(-2, 0, -2, 0);
+  }
+
+  gfx::Rect tiling_rect(tiling_size());
+
+  int around_left = TileAbsoluteXIndexFromSrcCoord(center_rect.x());
+  int around_top = TileAbsoluteYIndexFromSrcCoord(center_rect.y());
+  int right_src_coord = center_rect.right() - 1;
+  int around_right = TileAbsoluteXIndexFromSrcCoord(right_src_coord) + 1;
+  int bottom_src_coord = center_rect.bottom() - 1;
+  int around_bottom = TileAbsoluteYIndexFromSrcCoord(bottom_src_coord) + 1;
+
+  // For left and top indices check if tiling size is smaller than tile size. In
+  // such case if center rect is not intersecting the tiling rect and if center
+  // rect is right (or below) to the tiling rect, then around tile index is same
+  // as the index returned by TileAbsolute(X|Y)IndexFromSrcCoord().
+  if (!(num_tiles_x() == 1 && around_left == 0 &&
+        !tiling_rect.Intersects(center_rect) &&
+        tiling_rect.right() < center_rect.x())) {
+    around_left -= 1;
+  }
+  if (!(num_tiles_y() == 1 && around_top == 0 &&
+        !tiling_rect.Intersects(center_rect) &&
+        tiling_rect.bottom() < center_rect.y())) {
+    around_top -= 1;
+  }
+
+  return IndexRect(around_left, around_right, around_top, around_bottom);
+}
+
 gfx::Rect TilingData::ExpandRectIgnoringBordersToTileBounds(
     const gfx::Rect& rect) const {
   if (rect.IsEmpty() || has_empty_bounds())
     return gfx::Rect();
   if (rect.x() > tiling_size_.width() || rect.y() > tiling_size_.height())
     return gfx::Rect();
   int index_x = TileXIndexFromSrcCoord(rect.x());
   int index_y = TileYIndexFromSrcCoord(rect.y());
   int index_right = TileXIndexFromSrcCoord(rect.right() - 1);
   int index_bottom = TileYIndexFromSrcCoord(rect.bottom() - 1);
@@ skipping 153 matching lines @@
   return gfx::Vector2d(left, top);
 }
 
 void TilingData::RecomputeNumTiles() {
   num_tiles_x_ = ComputeNumTiles(
       max_texture_size_.width(), tiling_size_.width(), border_texels_);
   num_tiles_y_ = ComputeNumTiles(
       max_texture_size_.height(), tiling_size_.height(), border_texels_);
 }
 
+bool TilingData::IsPyramidSequenceEnabled() {
+  return true;
+}
+
 TilingData::BaseIterator::BaseIterator() : index_x_(-1), index_y_(-1) {
 }
 
 TilingData::Iterator::Iterator() : index_rect_(kNonPositiveQuadrantIndexRect) {
   done();
 }
 
 TilingData::Iterator::Iterator(const TilingData* tiling_data,
                                const gfx::Rect& consider_rect,
                                bool include_borders)
@@ skipping 166 matching lines @@
 }
 
 TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator() {
   done();
 }
 
 TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
-    const gfx::Rect& center_rect)
-    : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect) {
+    const gfx::Rect& center_rect,
+    const bool use_pyramid_sequence)
+    : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect),
+      use_pyramid_sequence_(use_pyramid_sequence) {
   if (!HasConsiderRect()) {
     done();
     return;
   }
 
-  IndexRect around_index_rect = tiling_data->TileAroundIndexRect(center_rect);
-  DCHECK(around_index_rect.is_valid());
+  if (use_pyramid_sequence_) {
+    IndexRect around_index_rect =
+        tiling_data->TileAroundAbsoluteIndexRect(center_rect);
 
-  spiral_iterator_ = SpiralIterator(around_index_rect, consider_index_rect_,
-                                    ignore_index_rect_);
+    DCHECK(around_index_rect.is_valid());
+    pyramid_sequence_ = PyramidSequence(
+        around_index_rect, consider_index_rect_, ignore_index_rect_,
+        tiling_data->max_texture_size().width(),
+        tiling_data->max_texture_size().height());
 
-  if (!spiral_iterator_) {
-    done();
-    return;
+    iterator_ = pyramid_sequence_.Begin();
+
+    if (!iterator_) {
+      done();
+      return;
+    }
+
+    index_x_ = iterator_.index_x();
+    index_y_ = iterator_.index_y();
+    DCHECK(consider_index_rect_.Contains(index_x_, index_y_) &&
+           !ignore_index_rect_.Contains(index_x_, index_y_));
+  } else {
+    IndexRect around_index_rect = tiling_data->TileAroundIndexRect(center_rect);
+    DCHECK(around_index_rect.is_valid());
+
+    spiral_iterator_ = SpiralIterator(around_index_rect, consider_index_rect_,
+                                      ignore_index_rect_);
+
+    if (!spiral_iterator_) {
+      done();
+      return;
+    }
+
+    index_x_ = spiral_iterator_.index_x();
+    index_y_ = spiral_iterator_.index_y();
   }
+}
 
-  index_x_ = spiral_iterator_.index_x();
-  index_y_ = spiral_iterator_.index_y();
-}
+TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
+    const TilingData::SpiralDifferenceIterator& other) = default;
+
+TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
+    TilingData::SpiralDifferenceIterator&& other) = default;
+
+TilingData::SpiralDifferenceIterator::~SpiralDifferenceIterator() {}
+
+TilingData::SpiralDifferenceIterator& TilingData::SpiralDifferenceIterator::
+operator=(const TilingData::SpiralDifferenceIterator& other) = default;
+
+TilingData::SpiralDifferenceIterator& TilingData::SpiralDifferenceIterator::
+operator=(TilingData::SpiralDifferenceIterator&& other) = default;
 
 TilingData::SpiralDifferenceIterator& TilingData::SpiralDifferenceIterator::
 operator++() {
-  ++spiral_iterator_;
+  if (use_pyramid_sequence_) {
+    ++iterator_;
 
-  if (!spiral_iterator_) {
-    done();
-    return *this;
+    if (!iterator_) {
+      done();
+      return *this;
+    }
+
+    index_x_ = iterator_.index_x();
+    index_y_ = iterator_.index_y();
+  } else {
+    ++spiral_iterator_;
+
+    if (!spiral_iterator_) {
+      done();
+      return *this;
+    }
+
+    index_x_ = spiral_iterator_.index_x();
+    index_y_ = spiral_iterator_.index_y();
   }
 
-  index_x_ = spiral_iterator_.index_x();
-  index_y_ = spiral_iterator_.index_y();
-
   return *this;
 }
 
 TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator() {
   done();
 }
 
 TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
-    const gfx::Rect& center_rect)
-    : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect) {
+    const gfx::Rect& center_rect,
+    const bool use_pyramid_sequence)
+    : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect),
+      use_pyramid_sequence_(use_pyramid_sequence) {
   if (!HasConsiderRect()) {
     done();
     return;
   }
 
-  IndexRect around_index_rect = tiling_data->TileAroundIndexRect(center_rect);
-  DCHECK(around_index_rect.is_valid());
+  if (use_pyramid_sequence_) {
+    IndexRect around_index_rect =
+        tiling_data->TileAroundAbsoluteIndexRect(center_rect);
+    DCHECK(around_index_rect.is_valid());
+    pyramid_sequence_ = PyramidSequence(
+        around_index_rect, consider_index_rect_, ignore_index_rect_,
+        tiling_data->max_texture_size().width(),
+        tiling_data->max_texture_size().height());
 
-  reverse_spiral_iterator_ = ReverseSpiralIterator(
-      around_index_rect, consider_index_rect_, ignore_index_rect_);
+    reverse_iterator_ = pyramid_sequence_.ReverseBegin();
 
-  if (!reverse_spiral_iterator_) {
-    done();
-    return;
+    if (!reverse_iterator_) {
+      done();
+      return;
+    }
+
+    index_x_ = reverse_iterator_.index_x();
+    index_y_ = reverse_iterator_.index_y();
+    DCHECK(consider_index_rect_.Contains(index_x_, index_y_) &&
+           !ignore_index_rect_.Contains(index_x_, index_y_));
+  } else {
+    IndexRect around_index_rect = tiling_data->TileAroundIndexRect(center_rect);
+    DCHECK(around_index_rect.is_valid());
+
+    reverse_spiral_iterator_ = ReverseSpiralIterator(
+        around_index_rect, consider_index_rect_, ignore_index_rect_);
+
+    if (!reverse_spiral_iterator_) {
+      done();
+      return;
+    }
+
+    index_x_ = reverse_spiral_iterator_.index_x();
+    index_y_ = reverse_spiral_iterator_.index_y();
   }
+}
 
-  index_x_ = reverse_spiral_iterator_.index_x();
-  index_y_ = reverse_spiral_iterator_.index_y();
-}
+TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
+    const TilingData::ReverseSpiralDifferenceIterator& other) = default;
+
+TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
+    TilingData::ReverseSpiralDifferenceIterator&& other) = default;
+
+TilingData::ReverseSpiralDifferenceIterator::
+    ~ReverseSpiralDifferenceIterator() {}
+
+TilingData::ReverseSpiralDifferenceIterator&
+TilingData::ReverseSpiralDifferenceIterator::operator=(
+    const TilingData::ReverseSpiralDifferenceIterator& other) = default;
+
+TilingData::ReverseSpiralDifferenceIterator&
+TilingData::ReverseSpiralDifferenceIterator::operator=(
+    TilingData::ReverseSpiralDifferenceIterator&& other) = default;
 
 TilingData::ReverseSpiralDifferenceIterator&
     TilingData::ReverseSpiralDifferenceIterator::
     operator++() {
-  ++reverse_spiral_iterator_;
+  if (use_pyramid_sequence_) {
+    ++reverse_iterator_;
 
-  if (!reverse_spiral_iterator_) {
-    done();
-    return *this;
+    if (!reverse_iterator_) {
+      done();
+      return *this;
+    }
+
+    index_x_ = reverse_iterator_.index_x();
+    index_y_ = reverse_iterator_.index_y();
+  } else {
+    ++reverse_spiral_iterator_;
+
+    if (!reverse_spiral_iterator_) {
+      done();
+      return *this;
+    }
+
+    index_x_ = reverse_spiral_iterator_.index_x();
+    index_y_ = reverse_spiral_iterator_.index_y();
   }
 
-  index_x_ = reverse_spiral_iterator_.index_x();
-  index_y_ = reverse_spiral_iterator_.index_y();
-
   return *this;
 }
 
 }  // namespace cc