Revert "cc: Added tile bundles"

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 206 matching lines @@
       did_check_for_completed_tasks_since_last_schedule_tasks_(true) {
   raster_worker_pool_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   CleanUpReleasedTiles();
-  DCHECK_EQ(0u, bundles_.size());
   DCHECK_EQ(0u, tiles_.size());
 
   RasterWorkerPool::RasterTask::Queue empty;
   raster_worker_pool_->ScheduleTasks(&empty);
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_->Shutdown();
   raster_worker_pool_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
 }
 
 void TileManager::Release(Tile* tile) {
   prioritized_tiles_dirty_ = true;
   released_tiles_.push_back(tile);
 }
 
-void TileManager::Release(TileBundle* bundle) {
-  released_tile_bundles_.push_back(bundle);
-}
-
 void TileManager::DidChangeTilePriority(Tile* tile) {
   prioritized_tiles_dirty_ = true;
 }
 
-void TileManager::DidChangeTileBundlePriority(TileBundle* bundle) {
-  prioritized_tiles_dirty_ = true;
-}
-
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
 void TileManager::CleanUpReleasedTiles() {
-  // Clean up bundles first, since they might have tiles that will become
-  // released as well.
-  for (std::vector<TileBundle*>::iterator it = released_tile_bundles_.begin();
-       it != released_tile_bundles_.end();
-       ++it) {
-    TileBundle* bundle = *it;
-    DCHECK(bundles_.find(bundle->id()) != bundles_.end());
-    bundles_.erase(bundle->id());
-    delete bundle;
-  }
-  released_tile_bundles_.clear();
-
   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
        it != released_tiles_.end();
        ++it) {
     Tile* tile = *it;
 
     FreeResourcesForTile(tile);
 
     DCHECK(tiles_.find(tile->id()) != tiles_.end());
     tiles_.erase(tile->id());
 
     LayerCountMap::iterator layer_it =
         used_layer_counts_.find(tile->layer_id());
     DCHECK_GT(layer_it->second, 0);
     if (--layer_it->second == 0) {
       used_layer_counts_.erase(layer_it);
       image_decode_tasks_.erase(tile->layer_id());
     }
 
     delete tile;
   }
+
   released_tiles_.clear();
 }
 
 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
   if (!prioritized_tiles_dirty_)
     return;
 
   CleanUpReleasedTiles();
 
   prioritized_tiles_.Clear();
@@ skipping 65 matching lines @@
   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 
   // Compute new stats to be return by GetMemoryStats().
   memory_required_bytes_ = 0;
   memory_nice_to_have_bytes_ = 0;
 
   const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
   const TreePriority tree_priority = global_state_.tree_priority;
 
   // For each tree, bin into different categories of tiles.
-  for (TileBundleMap::iterator bundle_it = bundles_.begin();
-       bundle_it != bundles_.end();
-       ++bundle_it) {
-    for (TileBundle::Iterator it(bundle_it->second); it; ++it) {
-      Tile* tile = *it;
-      ManagedTileState& mts = tile->managed_state();
+  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+    Tile* tile = it->second;
+    ManagedTileState& mts = tile->managed_state();
 
-      const ManagedTileState::TileVersion& tile_version =
-          tile->GetTileVersionForDrawing();
-      bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
-      bool tile_is_active =
-          tile_is_ready_to_draw ||
-          !mts.tile_versions[mts.raster_mode].raster_task_.is_null();
+    const ManagedTileState::TileVersion& tile_version =
+        tile->GetTileVersionForDrawing();
+    bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
+    bool tile_is_active =
+        tile_is_ready_to_draw ||
+        !mts.tile_versions[mts.raster_mode].raster_task_.is_null();
 
-      // Get the active priority and bin.
-      TilePriority active_priority = it.priority(ACTIVE_TREE);
-      ManagedTileBin active_bin = BinFromTilePriority(active_priority);
+    // Get the active priority and bin.
+    TilePriority active_priority = tile->priority(ACTIVE_TREE);
+    ManagedTileBin active_bin = BinFromTilePriority(active_priority);
 
-      // Get the pending priority and bin.
-      TilePriority pending_priority = it.priority(PENDING_TREE);
-      ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
+    // Get the pending priority and bin.
+    TilePriority pending_priority = tile->priority(PENDING_TREE);
+    ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
 
-      bool pending_is_low_res =
-          pending_priority.resolution == LOW_RESOLUTION;
-      bool pending_is_non_ideal =
-          pending_priority.resolution == NON_IDEAL_RESOLUTION;
-      bool active_is_non_ideal =
-          active_priority.resolution == NON_IDEAL_RESOLUTION;
+    bool pending_is_low_res =
+        pending_priority.resolution == LOW_RESOLUTION;
+    bool pending_is_non_ideal =
+        pending_priority.resolution == NON_IDEAL_RESOLUTION;
+    bool active_is_non_ideal =
+        active_priority.resolution == NON_IDEAL_RESOLUTION;
 
-      // Adjust pending bin state for low res tiles. This prevents
-      // pending tree low-res tiles from being initialized before
-      // high-res tiles.
-      if (pending_is_low_res)
-        pending_bin = std::max(pending_bin, EVENTUALLY_BIN);
+    // Adjust pending bin state for low res tiles. This prevents
+    // pending tree low-res tiles from being initialized before
+    // high-res tiles.
+    if (pending_is_low_res)
+      pending_bin = std::max(pending_bin, EVENTUALLY_BIN);
 
-      // Adjust bin state based on if ready to draw.
-      active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
-      pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
+    // Adjust bin state based on if ready to draw.
+    active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
+    pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
 
-      // Adjust bin state based on if active.
-      active_bin = kBinIsActiveMap[tile_is_active][active_bin];
-      pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
+    // Adjust bin state based on if active.
+    active_bin = kBinIsActiveMap[tile_is_active][active_bin];
+    pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
 
-      // We never want to paint new non-ideal tiles, as we always have
-      // a high-res tile covering that content (paint that instead).
-      if (!tile_is_ready_to_draw && active_is_non_ideal)
-        active_bin = NEVER_BIN;
-      if (!tile_is_ready_to_draw && pending_is_non_ideal)
-        pending_bin = NEVER_BIN;
+    // We never want to paint new non-ideal tiles, as we always have
+    // a high-res tile covering that content (paint that instead).
+    if (!tile_is_ready_to_draw && active_is_non_ideal)
+      active_bin = NEVER_BIN;
+    if (!tile_is_ready_to_draw && pending_is_non_ideal)
+      pending_bin = NEVER_BIN;
 
-      // Compute combined bin.
-      ManagedTileBin combined_bin = std::min(active_bin, pending_bin);
+    // Compute combined bin.
+    ManagedTileBin combined_bin = std::min(active_bin, pending_bin);
 
-      ManagedTileBin tree_bin[NUM_TREES];
-      tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
-      tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
+    ManagedTileBin tree_bin[NUM_TREES];
+    tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
+    tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
 
-      // The bin that the tile would have if the GPU memory manager had
-      // a maximally permissive policy, send to the GPU memory manager
-      // to determine policy.
-      ManagedTileBin gpu_memmgr_stats_bin = NEVER_BIN;
-      TilePriority tile_priority;
+    // The bin that the tile would have if the GPU memory manager had
+    // a maximally permissive policy, send to the GPU memory manager
+    // to determine policy.
+    ManagedTileBin gpu_memmgr_stats_bin = NEVER_BIN;
+    TilePriority tile_priority;
 
-      switch (tree_priority) {
-        case SAME_PRIORITY_FOR_BOTH_TREES:
-          mts.bin = kBinPolicyMap[memory_policy][combined_bin];
-          gpu_memmgr_stats_bin = combined_bin;
-          tile_priority = TilePriority(active_priority, pending_priority);
-          break;
-        case SMOOTHNESS_TAKES_PRIORITY:
-          mts.bin = tree_bin[ACTIVE_TREE];
-          gpu_memmgr_stats_bin = active_bin;
-          tile_priority = active_priority;
-          break;
-        case NEW_CONTENT_TAKES_PRIORITY:
-          mts.bin = tree_bin[PENDING_TREE];
-          gpu_memmgr_stats_bin = pending_bin;
-          tile_priority = pending_priority;
-          break;
-      }
+    switch (tree_priority) {
+      case SAME_PRIORITY_FOR_BOTH_TREES:
+        mts.bin = kBinPolicyMap[memory_policy][combined_bin];
+        gpu_memmgr_stats_bin = combined_bin;
+        tile_priority = tile->combined_priority();
+        break;
+      case SMOOTHNESS_TAKES_PRIORITY:
+        mts.bin = tree_bin[ACTIVE_TREE];
+        gpu_memmgr_stats_bin = active_bin;
+        tile_priority = active_priority;
+        break;
+      case NEW_CONTENT_TAKES_PRIORITY:
+        mts.bin = tree_bin[PENDING_TREE];
+        gpu_memmgr_stats_bin = pending_bin;
+        tile_priority = pending_priority;
+        break;
+    }
 
-      if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
-        if ((gpu_memmgr_stats_bin == NOW_BIN) ||
-            (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
-          memory_required_bytes_ += BytesConsumedIfAllocated(tile);
-        if (gpu_memmgr_stats_bin != NEVER_BIN)
-          memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
-      }
+    if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
+      if ((gpu_memmgr_stats_bin == NOW_BIN) ||
+          (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
+        memory_required_bytes_ += BytesConsumedIfAllocated(tile);
+      if (gpu_memmgr_stats_bin != NEVER_BIN)
+        memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
+    }
 
-      // Bump up the priority if we determined it's NEVER_BIN on one tree,
-      // but is still required on the other tree.
-      bool is_in_never_bin_on_both_trees =
-          tree_bin[ACTIVE_TREE] == NEVER_BIN &&
-          tree_bin[PENDING_TREE] == NEVER_BIN;
+    // Bump up the priority if we determined it's NEVER_BIN on one tree,
+    // but is still required on the other tree.
+    bool is_in_never_bin_on_both_trees =
+        tree_bin[ACTIVE_TREE] == NEVER_BIN &&
+        tree_bin[PENDING_TREE] == NEVER_BIN;
 
-      if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
-        mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
+    if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
+      mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
 
-      mts.resolution = tile_priority.resolution;
-      mts.time_to_needed_in_seconds = tile_priority.time_to_visible_in_seconds;
-      mts.distance_to_visible_in_pixels =
-          tile_priority.distance_to_visible_in_pixels;
-      mts.required_for_activation = tile_priority.required_for_activation;
+    mts.resolution = tile_priority.resolution;
+    mts.time_to_needed_in_seconds = tile_priority.time_to_visible_in_seconds;
+    mts.distance_to_visible_in_pixels =
+        tile_priority.distance_to_visible_in_pixels;
+    mts.required_for_activation = tile_priority.required_for_activation;
 
-      mts.visible_and_ready_to_draw =
-          tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
+    mts.visible_and_ready_to_draw =
+        tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 
-      if (mts.bin == NEVER_BIN) {
-        FreeResourcesForTile(tile);
-        continue;
-      }
+    if (mts.bin == NEVER_BIN) {
+      FreeResourcesForTile(tile);
+      continue;
+    }
 
-      // Note that if the tile is visible_and_ready_to_draw, then we always want
-      // the priority to be NOW_AND_READY_TO_DRAW_BIN, even if HIGH_PRIORITY_BIN
-      // is something different. The reason for this is that if we're
-      // prioritizing the pending tree, we still want visible tiles to take the
-      // highest priority.
-      ManagedTileBin priority_bin = mts.visible_and_ready_to_draw
-                                    ? NOW_AND_READY_TO_DRAW_BIN
-                                    : mts.bin;
+    // Note that if the tile is visible_and_ready_to_draw, then we always want
+    // the priority to be NOW_AND_READY_TO_DRAW_BIN, even if HIGH_PRIORITY_BIN
+    // is something different. The reason for this is that if we're prioritizing
+    // the pending tree, we still want visible tiles to take the highest
+    // priority.
+    ManagedTileBin priority_bin = mts.visible_and_ready_to_draw
+                                  ? NOW_AND_READY_TO_DRAW_BIN
+                                  : mts.bin;
 
-      // Insert the tile into a priority set.
-      tiles->InsertTile(tile, priority_bin);
-    }
+    // Insert the tile into a priority set.
+    tiles->InsertTile(tile, priority_bin);
   }
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
   // Update internal state.
   if (state != global_state_) {
     global_state_ = state;
     prioritized_tiles_dirty_ = true;
@@ skipping 461 matching lines @@
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile_version.set_use_resource();
     tile_version.resource_ = resource.Pass();
 
     bytes_releasable_ += BytesConsumedIfAllocated(tile);
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
-  if (tile->is_visible())
+  if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             gfx::Size tile_size,
                                             gfx::Rect content_rect,
                                             gfx::Rect opaque_rect,
                                             float contents_scale,
                                             int layer_id,
                                             int source_frame_number,
                                             int flags) {
   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
                                                          picture_pile,
                                                          tile_size,
                                                          content_rect,
                                                          opaque_rect,
                                                          contents_scale,
                                                          layer_id,
                                                          source_frame_number,
                                                          flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
   used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
   return tile;
 }
 
-scoped_refptr<TileBundle> TileManager::CreateTileBundle(int offset_x,
-                                                        int offset_y,
-                                                        int width,
-                                                        int height) {
-  scoped_refptr<TileBundle> bundle = make_scoped_refptr(
-      new TileBundle(this, offset_x, offset_y, width, height));
-  bundles_[bundle->id()] = bundle;
-  return bundle;
-}
-
 }  // namespace cc