cc: Remove tile sharing from tilings.

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 433 matching lines @@
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
     if (!eviction_priority_queue) {
       eviction_priority_queue =
           client_->BuildEvictionQueue(global_state_.tree_priority);
     }
     if (eviction_priority_queue->IsEmpty())
       break;
 
     Tile* tile = eviction_priority_queue->Top();
-    if (!other_priority.IsHigherPriorityThan(tile->combined_priority()))
+    if (!other_priority.IsHigherPriorityThan(tile->priority()))
       break;
 
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue->Pop();
   }
   return eviction_priority_queue;
 }
 
 bool TileManager::TilePriorityViolatesMemoryPolicy(
@@ skipping 34 matching lines @@
   MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
   scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue;
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     Tile* tile = raster_priority_queue->Top();
-    TilePriority priority = tile->combined_priority();
+    TilePriority priority = tile->priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
       TRACE_EVENT_INSTANT0(
           "cc", "TileManager::AssignGpuMemory tile violates memory policy",
           TRACE_EVENT_SCOPE_THREAD);
       break;
     }
 
     // We won't be able to schedule this tile, so break out early.
     if (tiles_that_need_to_be_rasterized->size() >=
@@ skipping 171 matching lines @@
 
     // Create and append new image decode task for this pixel ref.
     scoped_refptr<ImageDecodeTask> decode_task =
         CreateImageDecodeTask(tile, pixel_ref);
     decode_tasks.push_back(decode_task);
     existing_pixel_refs[id] = decode_task;
   }
 
   return make_scoped_refptr(new RasterTaskImpl(
       const_resource, tile->raster_source(), tile->content_rect(),
-      tile->contents_scale(), tile->combined_priority().resolution,
-      tile->layer_id(), static_cast<const void*>(tile),
-      tile->source_frame_number(), tile->use_picture_analysis(),
+      tile->contents_scale(), tile->priority().resolution, tile->layer_id(),
+      static_cast<const void*>(tile), tile->source_frame_number(),
+      tile->use_picture_analysis(),
       base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
                  tile->id(), base::Passed(&resource)),
       &decode_tasks));
 }
 
 void TileManager::OnImageDecodeTaskCompleted(int layer_id,
                                              SkPixelRef* pixel_ref,
                                              bool was_canceled) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
@@ skipping 84 matching lines @@
       client_->BuildRasterQueue(global_state_.tree_priority, type));
   // It is insufficient to check whether the raster queue we constructed is
   // empty. The reason for this is that there are situations (rasterize on
   // demand) when the tile both needs raster and it's ready to draw. Hence, we
   // have to iterate the queue to check whether the required tiles are ready to
   // draw.
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
     if (!raster_priority_queue->Top()->IsReadyToDraw())
       return false;
   }
+
+#if DCHECK_IS_ON()
+  scoped_ptr<RasterTilePriorityQueue> all_queue(
+      client_->BuildRasterQueue(global_state_.tree_priority, type));
+  for (; !all_queue->IsEmpty(); all_queue->Pop()) {
+    auto* tile = all_queue->Top();
+    DCHECK_IMPLIES(tile->required_for_activation(), tile->IsReadyToDraw());
+  }
+#endif
   return true;
 }
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
   return AreRequiredTilesReadyToDraw(
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 }
 
 bool TileManager::IsReadyToDraw() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToDraw");
@@ skipping 157 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc