cc: Partial tile update for one-copy raster.

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 17 matching lines @@
 // 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,
       RasterSource* raster_source,
       const gfx::Rect& content_rect,
+      const gfx::Rect& invalid_content_rect,
       float contents_scale,
       TileResolution tile_resolution,
       int layer_id,
-      const void* tile_id,
+      const void* tile,
+      uint64_t tile_id,
+      uint64_t previous_frame_tile_id,
       int source_frame_number,
       bool analyze_picture,
       const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>&
           reply,
       ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource, dependencies),
         raster_source_(raster_source),
         content_rect_(content_rect),
+        invalid_content_rect_(invalid_content_rect),
         contents_scale_(contents_scale),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
+        tile_(tile),
         tile_id_(tile_id),
+        previous_frame_tile_id_(previous_frame_tile_id),
         source_frame_number_(source_frame_number),
         analyze_picture_(analyze_picture),
         reply_(reply) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     if (analyze_picture_) {
       Analyze(raster_source_.get());
       if (analysis_.is_solid_color)
         return;
     }
 
     Raster(raster_source_.get());
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {
     DCHECK(!raster_buffer_);
-    raster_buffer_ = client->AcquireBufferForRaster(resource());
+    TileTaskData data(resource(), tile_id_, previous_frame_tile_id_,
+                      invalid_content_rect_);
+    raster_buffer_ = client->AcquireBufferForRaster(data);
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
   void RunReplyOnOriginThread() override {
     DCHECK(!raster_buffer_);
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
   void Analyze(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
-        tile_id_, tile_resolution_, source_frame_number_, layer_id_);
+        tile_, tile_resolution_, source_frame_number_, layer_id_);
 
     DCHECK(raster_source);
 
     raster_source->PerformSolidColorAnalysis(content_rect_, contents_scale_,
                                              &analysis_);
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
   void Raster(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
-        tile_id_, tile_resolution_, source_frame_number_, layer_id_);
+        tile_, tile_resolution_, source_frame_number_, layer_id_);
 
     DCHECK(raster_source);
 
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
                              contents_scale_);
   }
 
   RasterSource::SolidColorAnalysis analysis_;
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
+  gfx::Rect invalid_content_rect_;
   float contents_scale_;
   TileResolution tile_resolution_;
   int layer_id_;
-  const void* tile_id_;
+  const void* tile_;
+  uint64_t tile_id_;
+  uint64_t previous_frame_tile_id_;
   int source_frame_number_;
   bool analyze_picture_;
   const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
       reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
@@ skipping 440 matching lines @@
   TRACE_EVENT_END2("cc", "TileManager::AssignGpuMemoryToTiles",
                    "all_tiles_that_need_to_be_rasterized_are_scheduled",
                    all_tiles_that_need_to_be_rasterized_are_scheduled_,
                    "had_enough_memory_to_schedule_tiles_needed_now",
                    had_enough_memory_to_schedule_tiles_needed_now);
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   TileDrawInfo& draw_info = tile->draw_info();
   if (draw_info.resource_)
-    resource_pool_->ReleaseResource(draw_info.resource_.Pass());
+    resource_pool_->ReleaseResource(draw_info.resource_.Pass(), tile->id());
 }
 
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->IsReadyToDraw();
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     client_->NotifyTileStateChanged(tile);
 }
 
@@ skipping 83 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(), prioritized_tile.priority().resolution,
-      tile->layer_id(), static_cast<const void*>(tile),
-      tile->source_frame_number(), tile->use_picture_analysis(),
+      tile->invalidated_content_rect(), tile->contents_scale(),
+      prioritized_tile.priority().resolution, tile->layer_id(), tile,
+      tile->id(), tile->invalidated_id(), 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 19 matching lines @@
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
   DCHECK(tile->raster_task_.get());
   orphan_raster_tasks_.push_back(tile->raster_task_);
   tile->raster_task_ = nullptr;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
-    resource_pool_->ReleaseResource(resource.Pass());
+    resource_pool_->ReleaseResource(resource.Pass(), 0);
     return;
   }
 
   UpdateTileDrawInfo(tile, resource.Pass(), analysis);
 }
 
 void TileManager::UpdateTileDrawInfo(
     Tile* tile,
     scoped_ptr<ScopedResource> resource,
     const RasterSource::SolidColorAnalysis& analysis) {
   TileDrawInfo& draw_info = tile->draw_info();
 
   ++update_visible_tiles_stats_.completed_count;
 
   if (analysis.is_solid_color) {
     draw_info.set_solid_color(analysis.solid_color);
     if (resource)
-      resource_pool_->ReleaseResource(resource.Pass());
+      resource_pool_->ReleaseResource(resource.Pass(), tile->id());

[vmpstr, 2015/05/14 23:11:46]

This should be 0, because it's solid color: we might have not rasterized
anything into the texture, so you shouldn't reuse it if it becomes invalidated

[danakj, 2015/05/14 23:22:42]

Thanks, added comment too.

   } else {
     DCHECK(resource);
     draw_info.set_use_resource();
     draw_info.resource_ = resource.Pass();
   }
 
   client_->NotifyTileStateChanged(tile);
 }
 
 ScopedTilePtr TileManager::CreateTile(RasterSource* raster_source,
@@ skipping 211 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