cc: Added raster source.

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 15 matching lines @@
 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,
+      RasterSource* raster_source,
       const gfx::Rect& content_rect,
       float contents_scale,
       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,
+      const base::Callback<void(const RasterSource::Analysis&, bool)>& reply,
       ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource, dependencies),
-        picture_pile_(picture_pile),
+        raster_source_(raster_source),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         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:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
-    DCHECK(picture_pile_.get());
+    DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     if (analyze_picture_) {
-      Analyze(picture_pile_.get());
+      Analyze(raster_source_.get());
       if (analysis_.is_solid_color)
         return;
     }
 
-    Raster(picture_pile_.get());
+    Raster(raster_source_.get());
   }
 
   // Overridden from RasterizerTask:
   void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
     DCHECK(!raster_buffer_);
     raster_buffer_ = client->AcquireBufferForRaster(resource());
   }
   void CompleteOnOriginThread(RasterizerTaskClient* 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 PicturePileImpl* picture_pile) {
+  void Analyze(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
 
-    DCHECK(picture_pile);
+    DCHECK(raster_source);
 
-    picture_pile->AnalyzeInRect(
+    raster_source->AnalyzeInRect(
         content_rect_, contents_scale_, &analysis_, rendering_stats_);
 
     // 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) {
+  void Raster(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
     devtools_instrumentation::ScopedLayerTask layer_task(
         devtools_instrumentation::kRasterTask, layer_id_);
 
     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);
+    DCHECK(raster_source);
 
     raster_buffer_->Playback(
-        picture_pile_.get(), content_rect_, contents_scale_, stats);
+        raster_source_.get(), content_rect_, contents_scale_, stats);
 
     if (rendering_stats_->record_rendering_stats()) {
       base::TimeDelta current_rasterize_time =
           rendering_stats_->impl_thread_rendering_stats().rasterize_time;
       LOCAL_HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           100000,
           100);
     }
   }
 
-  PicturePileImpl::Analysis analysis_;
-  scoped_refptr<PicturePileImpl> picture_pile_;
+  RasterSource::Analysis analysis_;
+  scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   float contents_scale_;
   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_;
+  const base::Callback<void(const RasterSource::Analysis&, bool)> reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
                       int layer_id,
                       RenderingStatsInstrumentation* rendering_stats,
@@ skipping 564 matching lines @@
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ScopedResource> resource =
       resource_pool_->AcquireResource(tile->size());
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
-  for (PicturePileImpl::PixelRefIterator iter(
-           tile->content_rect(), tile->contents_scale(), tile->picture_pile());
-       iter;
-       ++iter) {
-    SkPixelRef* pixel_ref = *iter;
+  std::vector<SkPixelRef*> pixel_refs;
+  tile->raster_source()->GatherPixelRefs(
+      tile->content_rect(), tile->contents_scale(), &pixel_refs);
+  for (SkPixelRef* pixel_ref : pixel_refs) {
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
     if (decode_task_it != existing_pixel_refs.end()) {
       decode_tasks.push_back(decode_task_it->second);
       continue;
     }
 
     // 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->picture_pile(),
+                         tile->raster_source(),
                          tile->content_rect(),
                          tile->contents_scale(),
                          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),
@@ skipping 15 matching lines @@
     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,
-    const PicturePileImpl::Analysis& analysis,
-    bool was_canceled) {
+void TileManager::OnRasterTaskCompleted(Tile::Id tile_id,
+                                        scoped_ptr<ScopedResource> resource,
+                                        const RasterSource::Analysis& analysis,
+                                        bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
   ManagedTileState& mts = tile->managed_state();
   DCHECK(mts.raster_task.get());
   orphan_raster_tasks_.push_back(mts.raster_task);
   mts.raster_task = NULL;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
@@ skipping 10 matching lines @@
     mts.draw_info.set_use_resource();
     mts.draw_info.resource_ = resource.Pass();
   }
 
   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,
+scoped_refptr<Tile> TileManager::CreateTile(RasterSource* raster_source,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_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,
+                                                         raster_source,
                                                          tile_size,
                                                          content_rect,
                                                          contents_scale,
                                                          layer_id,
                                                          source_frame_number,
                                                          flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile.get();
   used_layer_counts_[tile->layer_id()]++;
@@ skipping 72 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