cc: Remove low quality mode and cleanup tile versions.

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>
 
 #include "base/bind.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/raster_buffer.h"
 #include "cc/resources/rasterizer.h"
 #include "cc/resources/tile.h"
-#include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
 class RasterTaskImpl : public RasterTask {
  public:
   RasterTaskImpl(
       const Resource* resource,
       PicturePileImpl* picture_pile,
       const gfx::Rect& content_rect,
       float contents_scale,
-      RasterMode raster_mode,
       TileResolution tile_resolution,
       int layer_id,
       const void* tile_id,
       int source_frame_number,
       bool analyze_picture,
       RenderingStatsInstrumentation* rendering_stats,
       const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
       ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
-        raster_mode_(raster_mode),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         analyze_picture_(analyze_picture),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
@@ skipping 40 matching lines @@
     // Record the solid color prediction.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
                           analysis_.is_solid_color);
 
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
   void Raster(const PicturePileImpl* picture_pile) {
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
-        tile_id_,
-        tile_resolution_,
-        source_frame_number_,
-        layer_id_,
-        raster_mode_);
+        tile_id_, tile_resolution_, source_frame_number_, layer_id_);
     devtools_instrumentation::ScopedLayerTask layer_task(
         devtools_instrumentation::kRasterTask, layer_id_);
 
     skia::RefPtr<SkCanvas> canvas = raster_buffer_->AcquireSkCanvas();
     DCHECK(canvas);
 
-    skia::RefPtr<SkDrawFilter> draw_filter;
-    switch (raster_mode_) {
-      case LOW_QUALITY_RASTER_MODE:
-        draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
-        break;
-      case HIGH_QUALITY_RASTER_MODE:
-        break;
-      case NUM_RASTER_MODES:
-      default:
-        NOTREACHED();
-    }
-    canvas->setDrawFilter(draw_filter.get());
-
     base::TimeDelta prev_rasterize_time =
         rendering_stats_->impl_thread_rendering_stats().rasterize_time;
 
     // Only record rasterization time for highres tiles, because
     // lowres tiles are not required for activation and therefore
     // introduce noise in the measurement (sometimes they get rasterized
     // before we draw and sometimes they aren't)
     RenderingStatsInstrumentation* stats =
         tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL;
     DCHECK(picture_pile);
@@ skipping 11 matching lines @@
           100);
     }
 
     raster_buffer_->ReleaseSkCanvas(canvas);
   }
 
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
-  RasterMode raster_mode_;
   TileResolution tile_resolution_;
   int layer_id_;
   const void* tile_id_;
   int source_frame_number_;
   bool analyze_picture_;
   RenderingStatsInstrumentation* rendering_stats_;
   const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
@@ skipping 335 matching lines @@
     bool allow_rasterize_on_demand =
         global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
         global_state_.memory_limit_policy != ALLOW_NOTHING;
 
     // Use on-demand raster for any required-for-activation tiles that have not
     // been been assigned memory after reaching a steady memory state. This
     // ensures that we activate even when OOM.
     for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
       Tile* tile = it->second;
       ManagedTileState& mts = tile->managed_state();
-      ManagedTileState::TileVersion& tile_version =
-          mts.tile_versions[mts.raster_mode];
+      ManagedTileState::TileDrawInfo& draw_info = mts.draw_info_;
 
-      if (tile->required_for_activation() && !tile_version.IsReadyToDraw()) {
+      if (tile->required_for_activation() && !draw_info.IsReadyToDraw()) {
         // If we can't raster on demand, give up early (and don't activate).
         if (!allow_rasterize_on_demand)
           return;
 
-        tile_version.set_rasterize_on_demand();
+        draw_info.set_rasterize_on_demand();
         client_->NotifyTileStateChanged(tile);
       }
     }
 
     DCHECK(IsReadyToActivate());
     ready_to_activate_check_notifier_.Schedule();
     return;
   }
 
   if (task_set == REQUIRED_FOR_ACTIVATION) {
@@ skipping 19 matching lines @@
   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 
   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 (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_.get();
+    const ManagedTileState::TileDrawInfo& draw_info = tile->GetTileDrawInfo();
+    bool tile_is_ready_to_draw = draw_info.IsReadyToDraw();
+    bool tile_is_active =
+        tile_is_ready_to_draw || mts.draw_info_.raster_task_.get();
 
     // 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 = tile->priority(PENDING_TREE);
     ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
 
     bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
@@ skipping 64 matching lines @@
     // smoothness takes priority or memory policy allows nothing to be
     // initialized.
     DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN ||
            tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
            memory_policy == ALLOW_NOTHING);
 
     // If the tile is in NEVER_BIN and it does not have an active task, then we
     // can release the resources early. If it does have the task however, we
     // should keep it in the prioritized tile set to ensure that AssignGpuMemory
     // can visit it.
-    if (mts.bin == NEVER_BIN &&
-        !mts.tile_versions[mts.raster_mode].raster_task_.get()) {
+    if (mts.bin == NEVER_BIN && !mts.draw_info_.raster_task_.get()) {
       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
       continue;
     }
 
     // Insert the tile into a priority set.
     tiles->InsertTile(tile, mts.bin);
   }
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
@@ skipping 113 matching lines @@
   bool oomed_hard = false;
   bool have_hit_soft_memory = false;  // Soft memory comes after hard.
 
   unsigned schedule_priority = 1u;
   for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
 
     mts.scheduled_priority = schedule_priority++;
 
-    mts.raster_mode = tile->DetermineOverallRasterMode();
-
-    ManagedTileState::TileVersion& tile_version =
-        mts.tile_versions[mts.raster_mode];
+    ManagedTileState::TileDrawInfo& draw_info = mts.draw_info_;
 
     // If this tile doesn't need a resource, then nothing to do.
-    if (!tile_version.requires_resource())
+    if (!draw_info.requires_resource())
       continue;
 
     // If the tile is not needed, free it up.
     if (mts.bin == NEVER_BIN) {
       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
       continue;
     }
 
     const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
     const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
     const size_t tile_bytes_left =
         (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
 
     // Hard-limit is reserved for tiles that would cause a calamity
     // if they were to go away, so by definition they are the highest
     // priority memory, and must be at the front of the list.
     DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit));
     have_hit_soft_memory |= !tile_uses_hard_limit;
 
     size_t tile_bytes = 0;
     size_t tile_resources = 0;
 
     // It costs to maintain a resource.
-    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
-      if (mts.tile_versions[mode].resource_) {
-        tile_bytes += bytes_if_allocated;
-        tile_resources++;
-      }
+    if (mts.draw_info_.resource_) {
+      tile_bytes += bytes_if_allocated;
+      tile_resources++;
     }
 
     // Allow lower priority tiles with initialized resources to keep
     // their memory by only assigning memory to new raster tasks if
     // they can be scheduled.
     bool reached_scheduled_raster_tasks_limit =
         tiles_that_need_to_be_rasterized->size() >= kScheduledRasterTasksLimit;
     if (!reached_scheduled_raster_tasks_limit) {
       // If we don't have the required version, and it's not in flight
       // then we'll have to pay to create a new task.
-      if (!tile_version.resource_ && !tile_version.raster_task_.get()) {
+      if (!draw_info.resource_ && !draw_info.raster_task_.get()) {
         tile_bytes += bytes_if_allocated;
         tile_resources++;
       }
     }
 
     // Tile is OOM.
     if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
 
       // This tile was already on screen and now its resources have been
       // released. In order to prevent checkerboarding, set this tile as
       // rasterize on demand immediately.
       if (mts.visible_and_ready_to_draw)
-        tile_version.set_rasterize_on_demand();
+        draw_info.set_rasterize_on_demand();
 
       oomed_soft = true;
       if (tile_uses_hard_limit) {
         oomed_hard = true;
         bytes_that_exceeded_memory_budget += tile_bytes;
       }
     } else {
       resources_left -= tile_resources;
       hard_bytes_left -= tile_bytes;
       soft_bytes_left =
           (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
-      if (tile_version.resource_)
+      if (draw_info.resource_)
         continue;
     }
 
-    DCHECK(!tile_version.resource_);
+    DCHECK(!draw_info.resource_);
 
     // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
     // has reached it's limit or we've failed to assign gpu memory to this
     // or any higher priority tile. Preventing tiles that fit into memory
     // budget to be rasterized when higher priority tile is oom is
     // important for two reasons:
     // 1. Tile size should not impact raster priority.
     // 2. Tiles with existing raster task could otherwise incorrectly
     //    be added as they are not affected by |bytes_allocatable|.
     bool can_schedule_tile =
@@ skipping 25 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget", oomed_hard);
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.hard_memory_limit_in_bytes;
   memory_stats_from_last_assign_.bytes_allocated =
       hard_bytes_allocatable - hard_bytes_left;
   memory_stats_from_last_assign_.bytes_unreleasable =
       resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_;
   memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget;
 }
 
-void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
+void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
-  if (mts.tile_versions[mode].resource_) {
-    resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass());
+  if (mts.draw_info_.resource_) {
+    resource_pool_->ReleaseResource(mts.draw_info_.resource_.Pass());
 
     DCHECK_GE(bytes_releasable_, BytesConsumedIfAllocated(tile));
     DCHECK_GE(resources_releasable_, 1u);
 
     bytes_releasable_ -= BytesConsumedIfAllocated(tile);
     --resources_releasable_;
   }
 }
 
-void TileManager::FreeResourcesForTile(Tile* tile) {
-  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
-    FreeResourceForTile(tile, static_cast<RasterMode>(mode));
-  }
-}
-
-void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
-  DCHECK(tile->IsReadyToDraw());
-  ManagedTileState& mts = tile->managed_state();
-  RasterMode used_mode = LOW_QUALITY_RASTER_MODE;
-  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
-    if (mts.tile_versions[mode].IsReadyToDraw()) {
-      used_mode = static_cast<RasterMode>(mode);
-      break;
-    }
-  }
-
-  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
-    if (mode != used_mode)
-      FreeResourceForTile(tile, static_cast<RasterMode>(mode));
-  }
-}
-
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->IsReadyToDraw();
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     client_->NotifyTileStateChanged(tile);
 }
 
 void TileManager::ScheduleTasks(
     const TileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc",
                "TileManager::ScheduleTasks",
                "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
   raster_queue_.Reset();
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
        it != tiles_that_need_to_be_rasterized.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
-    ManagedTileState::TileVersion& tile_version =
-        mts.tile_versions[mts.raster_mode];
+    ManagedTileState::TileDrawInfo& draw_info = mts.draw_info_;
 
-    DCHECK(tile_version.requires_resource());
-    DCHECK(!tile_version.resource_);
+    DCHECK(draw_info.requires_resource());
+    DCHECK(!draw_info.resource_);
 
-    if (!tile_version.raster_task_.get())
-      tile_version.raster_task_ = CreateRasterTask(tile);
+    if (!draw_info.raster_task_.get())
+      draw_info.raster_task_ = CreateRasterTask(tile);
 
     TaskSetCollection task_sets;
     if (tile->required_for_activation())
       task_sets.set(REQUIRED_FOR_ACTIVATION);
     task_sets.set(ALL);
     raster_queue_.items.push_back(
-        RasterTaskQueue::Item(tile_version.raster_task_.get(), task_sets));
+        RasterTaskQueue::Item(draw_info.raster_task_.get(), task_sets));
   }
 
   // We must reduce the amount of unused resoruces before calling
   // ScheduleTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Schedule running of |raster_tasks_|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |raster_tasks_|.
   rasterizer_->ScheduleTasks(&raster_queue_);
@@ skipping 48 matching lines @@
         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->picture_pile(),
                          tile->content_rect(),
                          tile->contents_scale(),
-                         mts.raster_mode,
                          mts.resolution,
                          tile->layer_id(),
                          static_cast<const void*>(tile),
                          tile->source_frame_number(),
                          tile->use_picture_analysis(),
                          rendering_stats_instrumentation_,
                          base::Bind(&TileManager::OnRasterTaskCompleted,
                                     base::Unretained(this),
                                     tile->id(),
-                                    base::Passed(&resource),
-                                    mts.raster_mode),
+                                    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_|.
   if (!was_canceled)
     return;
 
   LayerPixelRefTaskMap::iterator layer_it = image_decode_tasks_.find(layer_id);
   if (layer_it == image_decode_tasks_.end())
     return;
 
   PixelRefTaskMap& pixel_ref_tasks = layer_it->second;
   PixelRefTaskMap::iterator task_it =
       pixel_ref_tasks.find(pixel_ref->getGenerationID());
 
   if (task_it != pixel_ref_tasks.end())
     pixel_ref_tasks.erase(task_it);
 }
 
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     scoped_ptr<ScopedResource> resource,
-    RasterMode raster_mode,
     const PicturePileImpl::Analysis& analysis,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
   ManagedTileState& mts = tile->managed_state();
-  ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode];
-  DCHECK(tile_version.raster_task_.get());
-  orphan_raster_tasks_.push_back(tile_version.raster_task_);
-  tile_version.raster_task_ = NULL;
+  ManagedTileState::TileDrawInfo& draw_info = mts.draw_info_;
+  DCHECK(draw_info.raster_task_.get());
+  orphan_raster_tasks_.push_back(draw_info.raster_task_);
+  draw_info.raster_task_ = NULL;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   ++update_visible_tiles_stats_.completed_count;
 
   if (analysis.is_solid_color) {
-    tile_version.set_solid_color(analysis.solid_color);
+    draw_info.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
-    tile_version.set_use_resource();
-    tile_version.resource_ = resource.Pass();
+    draw_info.set_use_resource();
+    draw_info.resource_ = resource.Pass();
 
     bytes_releasable_ += BytesConsumedIfAllocated(tile);
     ++resources_releasable_;
   }
 
-  FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
     did_initialize_visible_tile_ = true;
 
   client_->NotifyTileStateChanged(tile);
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             float contents_scale,
@@ skipping 38 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