Pyramid sequence for testing

cc/tiles/tiling_set_raster_queue_all.cc

 // Copyright 2014 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/tiles/tiling_set_raster_queue_all.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 254 matching lines @@
 TilingSetRasterQueueAll::SkewportTilingIterator::SkewportTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
                               tiling_data,
                               PictureLayerTiling::SKEWPORT_RECT) {
   if (!tiling_->has_skewport_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
       tiling_data_, tiling_->current_skewport_rect(),
-      tiling_->current_visible_rect(), tiling_->current_visible_rect());
+      tiling_->current_visible_rect(), tiling_->current_visible_rect(),
+      TilingData::IsPyramidSequenceEnabled());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_)) {
     ++(*this);
     return;
   }
 }
 
 TilingSetRasterQueueAll::SkewportTilingIterator&
     TilingSetRasterQueueAll::SkewportTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
   return *this;
 }
 
 // SoonBorderTilingIterator.
 TilingSetRasterQueueAll::SoonBorderTilingIterator::SoonBorderTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
                               tiling_data,
                               PictureLayerTiling::SOON_BORDER_RECT) {
   if (!tiling_->has_soon_border_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
       tiling_data_, tiling_->current_soon_border_rect(),
-      tiling_->current_skewport_rect(), tiling_->current_visible_rect());
+      tiling_->current_skewport_rect(), tiling_->current_visible_rect(),
+      TilingData::IsPyramidSequenceEnabled());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_)) {
     ++(*this);
     return;
   }
 }
 
 TilingSetRasterQueueAll::SoonBorderTilingIterator&
     TilingSetRasterQueueAll::SoonBorderTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
   return *this;
 }
 
 // EventuallyTilingIterator.
 TilingSetRasterQueueAll::EventuallyTilingIterator::EventuallyTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
                               tiling_data,
                               PictureLayerTiling::EVENTUALLY_RECT) {
   if (!tiling_->has_eventually_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
       tiling_data_, tiling_->current_eventually_rect(),
-      tiling_->current_skewport_rect(), tiling_->current_soon_border_rect());
+      tiling_->current_skewport_rect(), tiling_->current_soon_border_rect(),
+      TilingData::IsPyramidSequenceEnabled());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_)) {
     ++(*this);
     return;
   }
 }
 
 TilingSetRasterQueueAll::EventuallyTilingIterator&
     TilingSetRasterQueueAll::EventuallyTilingIterator::
@@ skipping 11 matching lines @@
     TilingData* tiling_data)
     : tiling_(tiling), tiling_data_(tiling_data), phase_(Phase::VISIBLE_RECT) {
   visible_iterator_ = VisibleTilingIterator(tiling_, tiling_data_);
   if (visible_iterator_.done()) {
     AdvancePhase();
     return;
   }
   current_tile_ = *visible_iterator_;
 }
 
+TilingSetRasterQueueAll::TilingIterator::TilingIterator(
+    const TilingSetRasterQueueAll::TilingIterator& other) = default;
+
+TilingSetRasterQueueAll::TilingIterator::TilingIterator(
+    TilingSetRasterQueueAll::TilingIterator&& other) = default;
+
 TilingSetRasterQueueAll::TilingIterator::~TilingIterator() {
 }
 
+TilingSetRasterQueueAll::TilingIterator&
+TilingSetRasterQueueAll::TilingIterator::operator=(
+    const TilingSetRasterQueueAll::TilingIterator& other) = default;
+
+TilingSetRasterQueueAll::TilingIterator&
+TilingSetRasterQueueAll::TilingIterator::operator=(
+    TilingSetRasterQueueAll::TilingIterator&& other) = default;
+
 void TilingSetRasterQueueAll::TilingIterator::AdvancePhase() {
   DCHECK_LT(phase_, Phase::EVENTUALLY_RECT);
 
   current_tile_ = PrioritizedTile();
   while (!current_tile_.tile() && phase_ < Phase::EVENTUALLY_RECT) {
     phase_ = static_cast<Phase>(phase_ + 1);
     switch (phase_) {
       case Phase::VISIBLE_RECT:
         NOTREACHED();
         return;
@@ skipping 64 matching lines @@
         current_tile_ = PrioritizedTile();
         return *this;
       }
       current_tile_ = *eventually_iterator_;
       break;
   }
   return *this;
 }
 
 }  // namespace cc