cc: Ensure to skip the first tile that would be returned by twin.

cc/resources/raster_tile_priority_queue.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/resources/raster_tile_priority_queue.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 134 matching lines @@
                           ? PictureLayerImpl::LayerRasterTileIterator(
                                 layer_pair.active,
                                 tree_priority == SMOOTHNESS_TAKES_PRIORITY)
                           : PictureLayerImpl::LayerRasterTileIterator()),
       pending_iterator(layer_pair.pending
                            ? PictureLayerImpl::LayerRasterTileIterator(
                                  layer_pair.pending,
                                  tree_priority == SMOOTHNESS_TAKES_PRIORITY)
                            : PictureLayerImpl::LayerRasterTileIterator()),
       has_both_layers(layer_pair.active && layer_pair.pending) {
+  if (has_both_layers)
+    SkipTilesReturnedByTwin(tree_priority);
 }
 
 RasterTilePriorityQueue::PairedPictureLayerQueue::~PairedPictureLayerQueue() {
 }
 
 bool RasterTilePriorityQueue::PairedPictureLayerQueue::IsEmpty() const {
   return !active_iterator && !pending_iterator;
 }
 
 Tile* RasterTilePriorityQueue::PairedPictureLayerQueue::Top(
@@ skipping 13 matching lines @@
     TreePriority tree_priority) {
   DCHECK(!IsEmpty());
 
   WhichTree next_tree = NextTileIteratorTree(tree_priority);
   PictureLayerImpl::LayerRasterTileIterator* next_iterator =
       next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
   DCHECK(*next_iterator);
   DCHECK(returned_tiles_for_debug.insert(**next_iterator).second);
   ++(*next_iterator);
 
-  if (has_both_layers) {
-    // We have both layers (active and pending) thus we can encounter shared
-    // tiles twice (from the active iterator and from the pending iterator).
-    for (; !IsEmpty(); ++(*next_iterator)) {
-      next_tree = NextTileIteratorTree(tree_priority);
-      next_iterator =
-          next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
-
-      // Accept all non-shared tiles.
-      const Tile* tile = **next_iterator;
-      if (!tile->is_shared())
-        break;
-
-      // Accept a shared tile if the next tree is the higher priority one
-      // corresponding the iterator (active or pending) which usually (but due
-      // to spiral iterators not always) returns the shared tile first.
-      if (next_tree == HigherPriorityTree(tree_priority, NULL, NULL, tile))
-        break;
-    }
-  }
+  if (has_both_layers)
+    SkipTilesReturnedByTwin(tree_priority);
 
   // If no empty, use Top to do DCHECK the next iterator.
   DCHECK(IsEmpty() || Top(tree_priority));
 }
 
+void RasterTilePriorityQueue::PairedPictureLayerQueue::SkipTilesReturnedByTwin(
+    TreePriority tree_priority) {
+  // We have both layers (active and pending) thus we can encounter shared
+  // tiles twice (from the active iterator and from the pending iterator).
+  while (!IsEmpty()) {
+    WhichTree next_tree = NextTileIteratorTree(tree_priority);
+    PictureLayerImpl::LayerRasterTileIterator* next_iterator =
+        next_tree == ACTIVE_TREE ? &active_iterator : &pending_iterator;
+
+    // Accept all non-shared tiles.
+    const Tile* tile = **next_iterator;
+    if (!tile->is_shared())
+      break;
+
+    // Accept a shared tile if the next tree is the higher priority one
+    // corresponding the iterator (active or pending) which usually (but due
+    // to spiral iterators not always) returns the shared tile first.
+    if (next_tree == HigherPriorityTree(tree_priority, nullptr, nullptr, tile))
+      break;
+
+    ++(*next_iterator);

[reveman, 2014/10/10 15:30:40]

ah, we're advancing the iterator we decided to use above. thanks, I think a
while loop made this easier to understand. at least for me..

[vmpstr, 2014/10/10 15:36:18]

Same here :)

+  }
+}
+
 WhichTree
 RasterTilePriorityQueue::PairedPictureLayerQueue::NextTileIteratorTree(
     TreePriority tree_priority) const {
   DCHECK(!IsEmpty());
 
   // If we only have one iterator with tiles, return it.
   if (!active_iterator)
     return PENDING_TREE;
   if (!pending_iterator)
     return ACTIVE_TREE;
 
   // Now both iterators have tiles, so we have to decide based on tree priority.
   return HigherPriorityTree(
-      tree_priority, &active_iterator, &pending_iterator, NULL);
+      tree_priority, &active_iterator, &pending_iterator, nullptr);
 }
 
 }  // namespace cc