cc: Consider resolution when checking HigherPriorityTree.

cc/resources/raster_tile_priority_queue_all.cc

 // Copyright 2015 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_all.h"
 
 #include "cc/resources/tiling_set_raster_queue_all.h"
 
 namespace cc {
 
@@ skipping 68 matching lines @@
   }
 
  private:
   TreePriority tree_priority_;
 };
 
 WhichTree HigherPriorityTree(TreePriority tree_priority,
                              const TilingSetRasterQueueAll* active_queue,
                              const TilingSetRasterQueueAll* pending_queue,
                              const Tile* shared_tile) {
+  const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();

[enne (OOO), 2015/04/15 20:47:02]

Can you leave a comment about why you're doing this, here?

[vmpstr, 2015/04/15 21:05:24]

Done.

+  const Tile* pending_tile = shared_tile ? shared_tile : pending_queue->Top();
+  if (active_tile->priority(ACTIVE_TREE).resolution == NON_IDEAL_RESOLUTION)
+    return PENDING_TREE;
+  if (pending_tile->priority(PENDING_TREE).resolution == NON_IDEAL_RESOLUTION)
+    return ACTIVE_TREE;
+
   switch (tree_priority) {
     case SMOOTHNESS_TAKES_PRIORITY: {
-      const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();
-      const Tile* pending_tile =
-          shared_tile ? shared_tile : pending_queue->Top();
-
       const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
       const TilePriority& pending_priority =
           pending_tile->priority(PENDING_TREE);
 
       // If we're down to eventually bin tiles on the active tree, process the
       // pending tree to allow tiles required for activation to be initialized
       // when memory policy only allows prepaint.
       if (active_priority.priority_bin == TilePriority::EVENTUALLY &&
           pending_priority.priority_bin == TilePriority::NOW) {
         return PENDING_TREE;
       }
       return ACTIVE_TREE;
     }
     case NEW_CONTENT_TAKES_PRIORITY:
       return PENDING_TREE;
     case SAME_PRIORITY_FOR_BOTH_TREES: {
-      const Tile* active_tile = shared_tile ? shared_tile : active_queue->Top();
-      const Tile* pending_tile =
-          shared_tile ? shared_tile : pending_queue->Top();
-
       const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
       const TilePriority& pending_priority =
           pending_tile->priority(PENDING_TREE);
 
       if (active_priority.IsHigherPriorityThan(pending_priority))
         return ACTIVE_TREE;
       return PENDING_TREE;
     }
     default:
       NOTREACHED();
@@ skipping 188 matching lines @@
 
   state->BeginDictionary("pending_queue");
   state->SetBoolean("has_tile", active_queue_has_tile);
   state->SetInteger("active_priority_bin", active_priority_bin);
   state->SetInteger("pending_priority_bin", pending_priority_bin);
   state->EndDictionary();
   return state;
 }
 
 }  // namespace cc