cc: Remove cheapness estimator usage from tile manager.

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 <string>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 const size_t kMaxPendingUploadBytes = 100 * 1024 * 1024;
 const size_t kMaxPendingUploads = 1000;
 #endif
 
 #if defined(OS_ANDROID)
 const int kMaxNumPendingTasksPerThread = 8;
 #else
 const int kMaxNumPendingTasksPerThread = 40;
 #endif
 
-// Limit for time spent running cheap tasks during a single frame.
-// TODO(skyostil): Determine this limit more dynamically.
-const int kRunCheapTasksTimeMs = 6;
-
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 inline TileManagerBin BinFromTilePriority(const TilePriority& prio) {
   if (!prio.is_live)
     return NEVER_BIN;
 
   // The amount of time for which we want to have prepainting coverage.
   const float kPrepaintingWindowTimeSeconds = 1.0f;
   const float kBackflingGuardDistancePixels = 314.0f;
 
@@ skipping 52 matching lines @@
       DCHECK(false) << "Unrecognized TileManagerBinPriority value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileManagerBinPriority value>"));
   }
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
-    bool use_cheapness_estimator,
     bool use_color_estimator,
     bool prediction_benchmarking,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(this, num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_upload_(0),
       has_performed_uploads_since_last_flush_(false),
       ever_exceeded_memory_budget_(false),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
-      use_cheapness_estimator_(use_cheapness_estimator),
       use_color_estimator_(use_color_estimator),
       prediction_benchmarking_(prediction_benchmarking),
       did_initialize_visible_tile_(false),
       pending_tasks_(0),
       max_pending_tasks_(kMaxNumPendingTasksPerThread * num_raster_threads) {
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_.reset();
   AbortPendingTileUploads();
   DCHECK_EQ(0u, tiles_with_pending_upload_.size());
   DCHECK_EQ(0u, all_tiles_.size());
   DCHECK_EQ(0u, live_or_allocated_tiles_.size());
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes);
   ScheduleManageTiles();
-  UpdateCheapTasksTimeLimit();
 }
 
 void TileManager::RegisterTile(Tile* tile) {
   all_tiles_.insert(tile);
   ScheduleManageTiles();
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
   for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin();
        it != tiles_that_need_to_be_rasterized_.end(); it++) {
@@ skipping 474 matching lines @@
       tiles_with_image_decoding_tasks.rend());
 
   if (did_initialize_visible_tile_) {
     did_initialize_visible_tile_ = false;
     client_->DidInitializeVisibleTile();
   }
 }
 
 void TileManager::AnalyzeTile(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
-  if ((use_cheapness_estimator_ || use_color_estimator_) &&
-      !managed_tile_state.picture_pile_analyzed) {
+  if (use_color_estimator_ && !managed_tile_state.picture_pile_analyzed) {
     tile->picture_pile()->AnalyzeInRect(
         tile->content_rect(),
         tile->contents_scale(),
         &managed_tile_state.picture_pile_analysis);
-    managed_tile_state.picture_pile_analysis.is_cheap_to_raster &=
-        use_cheapness_estimator_;
     managed_tile_state.picture_pile_analysis.is_solid_color &=
         use_color_estimator_;
     managed_tile_state.picture_pile_analysis.is_transparent &=
         use_color_estimator_;
     managed_tile_state.picture_pile_analyzed = true;
     managed_tile_state.need_to_gather_pixel_refs = false;
     managed_tile_state.pending_pixel_refs.swap(
         managed_tile_state.picture_pile_analysis.lazy_pixel_refs);
 
     if (managed_tile_state.picture_pile_analysis.is_solid_color) {
@@ skipping 101 matching lines @@
       tile->tile_size_.size(),
       tile->drawing_info().resource_format_);
   resource_pool_->resource_provider()->AcquirePixelBuffer(resource->id());
 
   tile->drawing_info().resource_is_being_initialized_ = true;
   tile->drawing_info().can_be_freed_ = false;
 
   return resource.Pass();
 }
 
-void TileManager::SetAnticipatedDrawTime(base::TimeTicks time) {
-  anticipated_draw_time_ = time;
-  UpdateCheapTasksTimeLimit();
-}
-
-void TileManager::UpdateCheapTasksTimeLimit() {
-  base::TimeTicks limit;
-  if (use_cheapness_estimator_ &&
-      global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY) {
-    limit = std::min(
-        base::TimeTicks::Now() +
-            base::TimeDelta::FromMilliseconds(kRunCheapTasksTimeMs),
-        anticipated_draw_time_);
-  }
-  raster_worker_pool_->SetRunCheapTasksTimeLimit(limit);
-}
-
 void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
   uint8* buffer =
       resource_pool_->resource_provider()->MapPixelBuffer(resource_id);
 
   CHECK(buffer);
   // skia requires that our buffer be 4-byte aligned
   CHECK(!(reinterpret_cast<intptr_t>(buffer) & 3));
 
-  ManagedTileState& managed_tile_state = tile->managed_state();
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
-      managed_tile_state.picture_pile_analysis.is_cheap_to_raster,
       base::Bind(&TileManager::RunRasterTask,
                  buffer,
                  tile->content_rect(),
                  tile->contents_scale(),
                  GetRasterTaskMetadata(*tile),
                  rendering_stats_instrumentation_),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
@@ skipping 104 matching lines @@
 
     HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeUS",
                             raster_stats.total_rasterize_time.InMicroseconds(),
                             0,
                             100000,
                             100);
 
     if (metadata.prediction_benchmarking) {
       PicturePileImpl::Analysis analysis;
       picture_pile->AnalyzeInRect(rect, contents_scale, &analysis);
-      bool is_predicted_cheap = analysis.is_cheap_to_raster;
-      bool is_actually_cheap =
-          raster_stats.best_rasterize_time.InMillisecondsF() <= 1.0f;
-      RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
 
       DCHECK_EQ(bitmap.rowBytes(),
                 static_cast<size_t>(bitmap.width() * bitmap.bytesPerPixel()));
 
       RecordSolidColorPredictorResults(
           reinterpret_cast<SkColor*>(bitmap.getPixels()),
           bitmap.getSize() / bitmap.bytesPerPixel(),
           analysis.is_solid_color,
           analysis.solid_color,
           analysis.is_transparent);
     }
   } else {
     picture_pile->Raster(&canvas, rect, contents_scale, NULL);
   }
 }
 
 // static
-void TileManager::RecordCheapnessPredictorResults(bool is_predicted_cheap,
-                                                  bool is_actually_cheap) {
-  if (is_predicted_cheap && !is_actually_cheap)
-    HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorBadlyWrong", true);
-  else if (!is_predicted_cheap && is_actually_cheap)
-    HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorSafelyWrong", true);
-
-  HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorAccuracy",
-                    is_predicted_cheap == is_actually_cheap);
-}
-
-// static
 void TileManager::RecordSolidColorPredictorResults(
     const SkColor* actual_colors,
     size_t color_count,
     bool is_predicted_solid,
     SkColor predicted_color,
     bool is_predicted_transparent) {
   DCHECK_GT(color_count, 0u);
 
   bool is_actually_solid = true;
   bool is_transparent = true;
@@ skipping 42 matching lines @@
     skia::LazyPixelRef* pixel_ref,
     RenderingStatsInstrumentation* stats_instrumentation) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks start_time = stats_instrumentation->StartRecording();
   pixel_ref->Decode();
   base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
   stats_instrumentation->AddDeferredImageDecode(duration);
 }
 
 }  // namespace cc