Consider occluded tiles during eviction with occluded as Tile property.

cc/resources/tile_manager.cc

 // Copyright 2012 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/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 1515 matching lines @@
   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;
 
   // Now we have to return true iff b is lower priority than a.
 
-  // 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.
+  // If the priority bin differs, b is lower priority if it has the higher
+  // priority bin.
+  if (a_priority.priority_bin != b_priority.priority_bin)
+    return b_priority.priority_bin > a_priority.priority_bin;
+
+  // Otherwise if the resolution differs, 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) {
+  if (b_priority.resolution != a_priority.resolution) {
     // Non ideal resolution should be sorted higher than other resolutions.
     if (a_priority.resolution == NON_IDEAL_RESOLUTION)
       return false;
 
     if (b_priority.resolution == NON_IDEAL_RESOLUTION)
       return true;
 
     if (prioritize_low_res)
       return a_priority.resolution == LOW_RESOLUTION;
 
     return a_priority.resolution == HIGH_RESOLUTION;
   }
-  return a_priority.IsHigherPriorityThan(b_priority);
+
+  // Otherwise if the occlusion differs, b is lower priority if it is occluded.
+  bool a_is_occluded = a_tile->is_occluded_for_tree_priority(tree_priority_);
+  bool b_is_occluded = b_tile->is_occluded_for_tree_priority(tree_priority_);
+
+  if (a_is_occluded != b_is_occluded)
+    return b_is_occluded;
+
+  // Otherwise if the distance to visible differs, b is lower priorty if it is

[vmpstr, 2014/07/11 00:44:32]

nit: you don't need the "if the distance to visible differs" part in the comment

[jbedley, 2014/07/11 18:00:30]

Done.

+  // farther from visible.
+  return b_priority.distance_to_visible > a_priority.distance_to_visible;
 }
 
 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
   rasterizer_ = rasterizer;
   rasterizer_->SetClient(this);
 }
 
 bool TileManager::IsReadyToActivate() const {
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
@@ skipping 11 matching lines @@
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
   rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (IsReadyToActivate())
     client_->NotifyReadyToActivate();
 }
 
 }  // namespace cc