Update from chromium 62675d9fb31fb8cedc40f68e78e8445a74f362e7

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 {
 
 class RasterOrderComparator {
  public:
   explicit RasterOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
 
   bool operator()(
       const RasterTilePriorityQueue::PairedPictureLayerQueue* a,
       const RasterTilePriorityQueue::PairedPictureLayerQueue* b) const {
     // Note that in this function, we have to return true if and only if
-    // b is strictly lower priority than a. Note that for the sake of
+    // a is strictly lower priority than b. Note that for the sake of
     // completeness, empty queue is considered to have lowest priority.
     if (a->IsEmpty() || b->IsEmpty())
       return b->IsEmpty() < a->IsEmpty();
 
     WhichTree a_tree = a->NextTileIteratorTree(tree_priority_);
     const PictureLayerImpl::LayerRasterTileIterator* a_iterator =
         a_tree == ACTIVE_TREE ? &a->active_iterator : &a->pending_iterator;
 
     WhichTree b_tree = b->NextTileIteratorTree(tree_priority_);
     const PictureLayerImpl::LayerRasterTileIterator* b_iterator =
         b_tree == ACTIVE_TREE ? &b->active_iterator : &b->pending_iterator;
 
     const Tile* a_tile = **a_iterator;
     const Tile* b_tile = **b_iterator;
 
     const TilePriority& a_priority =
         a_tile->priority_for_tree_priority(tree_priority_);
     const TilePriority& b_priority =
         b_tile->priority_for_tree_priority(tree_priority_);
     bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
 
+    // In smoothness mode, we should return pending NOW tiles before active
+    // EVENTUALLY tiles. So if both priorities here are eventually, we need to
+    // check the pending priority.
+    if (prioritize_low_res &&
+        a_priority.priority_bin == TilePriority::EVENTUALLY &&
+        b_priority.priority_bin == TilePriority::EVENTUALLY) {
+      bool a_is_pending_now =
+          a_tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW;
+      bool b_is_pending_now =
+          b_tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW;
+      if (a_is_pending_now || b_is_pending_now)
+        return a_is_pending_now < b_is_pending_now;
+
+      // In case neither one is pending now, fall through.
+    }
+
     // If the bin is the same but the resolution is not, then the order will be
     // determined by whether we prioritize low res or not.
     // TODO(vmpstr): Remove this when TilePriority is no longer a member of Tile
     // class but instead produced by the iterators.
     if (b_priority.priority_bin == a_priority.priority_bin &&
         b_priority.resolution != a_priority.resolution) {
       // Non ideal resolution should be sorted lower than other resolutions.
       if (a_priority.resolution == NON_IDEAL_RESOLUTION)
         return true;
 
       if (b_priority.resolution == NON_IDEAL_RESOLUTION)
         return false;
 
       if (prioritize_low_res)
         return b_priority.resolution == LOW_RESOLUTION;
       return b_priority.resolution == HIGH_RESOLUTION;
     }
+
     return b_priority.IsHigherPriorityThan(a_priority);
   }
 
  private:
   TreePriority tree_priority_;
 };
 
 WhichTree HigherPriorityTree(
     TreePriority tree_priority,
     const PictureLayerImpl::LayerRasterTileIterator* active_iterator,
@@ skipping 215 matching lines @@
           ? (*pending_iterator)->priority(PENDING_TREE).priority_bin
           : TilePriority::EVENTUALLY;
   state->SetBoolean("has_tile", !!pending_iterator);
   state->SetInteger("active_priority_bin", active_priority_bin);
   state->SetInteger("pending_priority_bin", pending_priority_bin);
   state->EndDictionary();
   return state;
 }
 
 }  // namespace cc