cc: Remove tile sharing from tilings.

cc/resources/tiling_set_raster_queue_all.cc

Index: cc/resources/tiling_set_raster_queue_all.cc
diff --git a/cc/resources/tiling_set_raster_queue_all.cc b/cc/resources/tiling_set_raster_queue_all.cc
index 2ccba67eeb31e637ff39644507d23e1c0bf83d31..6d7dc581e5bf5cd97fa36dbddc068c5d11347c37 100644
--- a/cc/resources/tiling_set_raster_queue_all.cc
+++ b/cc/resources/tiling_set_raster_queue_all.cc
@@ -173,11 +173,33 @@ TilingSetRasterQueueAll::VisibleTilingIterator&
   return *this;
 }
 
+// PendingVisibleTilingIterator.
+TilingSetRasterQueueAll::PendingVisibleTilingIterator::
+    PendingVisibleTilingIterator(PictureLayerTiling* tiling,
+                                 TilingData* tiling_data)
+    : OnePriorityRectIterator(tiling, tiling_data) {
+  iterator_ = TilingData::DifferenceIterator(tiling_data_,
+                                             tiling_->pending_visible_rect(),

[enne (OOO), 2015/04/02 21:45:34]

pending and current are super confusing to me when reading code, because
sometimes they're the same and sometimes they're not.

I understand why you have the pending function, because it's super convenient.

In this call site, since this is the PendingVisibleTilingIterator, should these
both be current_visible_rect?

[vmpstr, 2015/04/02 22:33:27]

At this point we don't really know if the tiling set is coming from the pending
tree or the active tree... For the active tree, this does an actual difference
between what the pending visible rect is and what the currently set visible rect
is. For the pending tree, these are both the same and the iterator will be
empty. 

+                                             tiling_->current_visible_rect());
+  if (!iterator_)
+    return;
+  if (!GetFirstTileAndCheckIfValid(&iterator_))
+    ++(*this);
+}
+
+TilingSetRasterQueueAll::PendingVisibleTilingIterator&
+    TilingSetRasterQueueAll::PendingVisibleTilingIterator::
+    operator++() {
+  AdvanceToNextTile(&iterator_);
+  return *this;
+}
+
 // SkewportTilingIterator.
 TilingSetRasterQueueAll::SkewportTilingIterator::SkewportTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data) {
+    : OnePriorityRectIterator(tiling, tiling_data),
+      pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_skewport_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
@@ -185,7 +207,11 @@ TilingSetRasterQueueAll::SkewportTilingIterator::SkewportTilingIterator(
       tiling_->current_visible_rect(), tiling_->current_visible_rect());
   if (!iterator_)
     return;
-  if (!GetFirstTileAndCheckIfValid(&iterator_))
+  if (!GetFirstTileAndCheckIfValid(&iterator_)) {
+    ++(*this);
+    return;
+  }
+  if (tile_->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
 
@@ -193,6 +219,11 @@ TilingSetRasterQueueAll::SkewportTilingIterator&
     TilingSetRasterQueueAll::SkewportTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
+  while (!done()) {
+    if (!tile_->content_rect().Intersects(pending_visible_rect_))
+      break;
+    AdvanceToNextTile(&iterator_);
+  }
   return *this;
 }
 
@@ -200,7 +231,8 @@ TilingSetRasterQueueAll::SkewportTilingIterator&
 TilingSetRasterQueueAll::SoonBorderTilingIterator::SoonBorderTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data) {
+    : OnePriorityRectIterator(tiling, tiling_data),
+      pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_soon_border_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
@@ -208,7 +240,11 @@ TilingSetRasterQueueAll::SoonBorderTilingIterator::SoonBorderTilingIterator(
       tiling_->current_skewport_rect(), tiling_->current_visible_rect());
   if (!iterator_)
     return;
-  if (!GetFirstTileAndCheckIfValid(&iterator_))
+  if (!GetFirstTileAndCheckIfValid(&iterator_)) {
+    ++(*this);
+    return;
+  }
+  if (tile_->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
 
@@ -216,6 +252,11 @@ TilingSetRasterQueueAll::SoonBorderTilingIterator&
     TilingSetRasterQueueAll::SoonBorderTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
+  while (!done()) {
+    if (!tile_->content_rect().Intersects(pending_visible_rect_))
+      break;
+    AdvanceToNextTile(&iterator_);
+  }
   return *this;
 }
 
@@ -223,7 +264,8 @@ TilingSetRasterQueueAll::SoonBorderTilingIterator&
 TilingSetRasterQueueAll::EventuallyTilingIterator::EventuallyTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data) {
+    : OnePriorityRectIterator(tiling, tiling_data),
+      pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_eventually_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
@@ -231,7 +273,11 @@ TilingSetRasterQueueAll::EventuallyTilingIterator::EventuallyTilingIterator(
       tiling_->current_skewport_rect(), tiling_->current_soon_border_rect());
   if (!iterator_)
     return;
-  if (!GetFirstTileAndCheckIfValid(&iterator_))
+  if (!GetFirstTileAndCheckIfValid(&iterator_)) {
+    ++(*this);
+    return;
+  }
+  if (tile_->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
 
@@ -239,6 +285,11 @@ TilingSetRasterQueueAll::EventuallyTilingIterator&
     TilingSetRasterQueueAll::EventuallyTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
+  while (!done()) {
+    if (!tile_->content_rect().Intersects(pending_visible_rect_))
+      break;
+    AdvanceToNextTile(&iterator_);
+  }
   return *this;
 }
 
@@ -262,6 +313,9 @@ TilingSetRasterQueueAll::TilingIterator::TilingIterator(
   current_tile_ = *visible_iterator_;
 }
 
+TilingSetRasterQueueAll::TilingIterator::~TilingIterator() {
+}
+
 void TilingSetRasterQueueAll::TilingIterator::AdvancePhase() {
   DCHECK_LT(phase_, EVENTUALLY_RECT);
 
@@ -272,6 +326,12 @@ void TilingSetRasterQueueAll::TilingIterator::AdvancePhase() {
       case VISIBLE_RECT:
         NOTREACHED();
         return;
+      case PENDING_VISIBLE_RECT:
+        pending_visible_iterator_ =
+            PendingVisibleTilingIterator(tiling_, tiling_data_);
+        if (!pending_visible_iterator_.done())
+          current_tile_ = *pending_visible_iterator_;
+        break;
       case SKEWPORT_RECT:
         skewport_iterator_ = SkewportTilingIterator(tiling_, tiling_data_);
         if (!skewport_iterator_.done())
@@ -303,6 +363,14 @@ TilingSetRasterQueueAll::TilingIterator&
       }
       current_tile_ = *visible_iterator_;
       break;
+    case PENDING_VISIBLE_RECT:
+      ++pending_visible_iterator_;
+      if (pending_visible_iterator_.done()) {
+        AdvancePhase();
+        return *this;
+      }
+      current_tile_ = *pending_visible_iterator_;
+      break;
     case SKEWPORT_RECT:
       ++skewport_iterator_;
       if (skewport_iterator_.done()) {