cc: Encapsulate rastering related data in RasteringInfo.

cc/tiles/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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/histograms.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/raster/rastering_info.h"
 #include "cc/raster/task_category.h"
 #include "cc/raster/tile_task_runner.h"
 #include "cc/tiles/tile.h"
 #include "ui/gfx/geometry/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;
 
 DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     ScopedRasterTaskTimer,
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
 class RasterTaskImpl : public Task {
  public:
-  RasterTaskImpl(RasterBufferProvider* raster_buffer_provider,
-                 const Resource* resource,
-                 scoped_refptr<RasterSource> raster_source,
-                 const gfx::Rect& content_rect,
-                 const gfx::Rect& invalid_content_rect,
-                 float contents_scale,
-                 const RasterSource::PlaybackSettings& playback_settings,
-                 TileResolution tile_resolution,
-                 int layer_id,
-                 uint64_t source_prepare_tiles_id,
-                 const void* tile,
-                 uint64_t new_content_id,
-                 uint64_t previous_content_id,
-                 uint64_t resource_content_id,
-                 int source_frame_number,
-                 const base::Callback<void(bool)>& reply,
+  RasterTaskImpl(scoped_ptr<RasteringInfo> rastering_info,
                  Task::Vector* dependencies)
-      : Task(dependencies),
-        raster_buffer_provider_(raster_buffer_provider),
-        resource_(resource),
-        raster_source_(std::move(raster_source)),
-        content_rect_(content_rect),
-        invalid_content_rect_(invalid_content_rect),
-        contents_scale_(contents_scale),
-        playback_settings_(playback_settings),
-        tile_resolution_(tile_resolution),
-        layer_id_(layer_id),
-        source_prepare_tiles_id_(source_prepare_tiles_id),
-        tile_(tile),
-        new_content_id_(new_content_id),
-        previous_content_id_(previous_content_id),
-        resource_content_id_(resource_content_id),
-        source_frame_number_(source_frame_number),
-        reply_(reply) {}
+      : Task(dependencies), rastering_info_(std::move(rastering_info)) {}
 
   // Overridden from Task:
   void ScheduleOnOriginThread() override {
-    DCHECK(raster_buffer_provider_);
-    DCHECK(!raster_buffer_);
-    raster_buffer_ = raster_buffer_provider_->AcquireBufferForRaster(
-        resource_, resource_content_id_, previous_content_id_);
+    DCHECK(rastering_info_->raster_buffer_provider);
+    DCHECK(!rastering_info_->raster_buffer);
+    rastering_info_->raster_buffer =
+        rastering_info_->raster_buffer_provider->AcquireBufferForRaster(
+            rastering_info_->resource, rastering_info_->resource_content_id,
+            rastering_info_->previous_content_id);
   }
 
   void CompleteOnOriginThread() override {
-    DCHECK(raster_buffer_provider_);
-    raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer_));
-    reply_.Run(!HasFinishedRunning());
+    DCHECK(rastering_info_->raster_buffer_provider);
+    rastering_info_->raster_buffer_provider->ReleaseBufferForRaster(
+        std::move(rastering_info_->raster_buffer));
+    rastering_info_->reply.Run(!HasFinishedRunning());
   }
 
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
-                 "source_prepare_tiles_id", source_prepare_tiles_id_);
+                 "source_prepare_tiles_id",
+                 rastering_info_->source_prepare_tiles_id);
 
-    DCHECK(raster_source_.get());
-    DCHECK(raster_buffer_);
+    DCHECK(rastering_info_->raster_source.get());
+    DCHECK(rastering_info_->raster_buffer);
 
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
-        tile_, tile_resolution_, source_frame_number_, layer_id_);
+        rastering_info_->tile, rastering_info_->tile_resolution,
+        rastering_info_->source_frame_number, rastering_info_->layer_id);
     ScopedRasterTaskTimer timer;
-    timer.SetArea(content_rect_.size().GetArea());
+    timer.SetArea(rastering_info_->content_rect.size().GetArea());
 
-    DCHECK(raster_source_);
+    DCHECK(rastering_info_->raster_source);
 
-    raster_buffer_->Playback(raster_source_.get(), content_rect_,
-                             invalid_content_rect_, new_content_id_,
-                             contents_scale_, playback_settings_);
+    rastering_info_->raster_buffer->Playback(
+        rastering_info_->raster_source.get(), rastering_info_->content_rect,
+        rastering_info_->invalid_content_rect, rastering_info_->new_content_id,
+        rastering_info_->contents_scale, rastering_info_->playback_settings);
   }
 
  protected:
-  ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
+  ~RasterTaskImpl() override { DCHECK(!rastering_info_->raster_buffer); }
 
  private:
-  RasterBufferProvider* raster_buffer_provider_;
-  const Resource* resource_;
-  scoped_refptr<RasterSource> raster_source_;
-  gfx::Rect content_rect_;
-  gfx::Rect invalid_content_rect_;
-  float contents_scale_;
-  RasterSource::PlaybackSettings playback_settings_;
-  TileResolution tile_resolution_;
-  int layer_id_;
-  uint64_t source_prepare_tiles_id_;
-  const void* tile_;
-  uint64_t new_content_id_;
-  uint64_t previous_content_id_;
-  uint64_t resource_content_id_;
-  int source_frame_number_;
-  const base::Callback<void(bool)> reply_;
-  scoped_ptr<RasterBuffer> raster_buffer_;
+  scoped_ptr<RasteringInfo> rastering_info_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 // Task priorities that make sure that the task set done tasks run before any
 // other remaining tasks.
 const size_t kRequiredForActivationDoneTaskPriority = 1u;
 const size_t kRequiredForDrawDoneTaskPriority = 2u;
 const size_t kAllDoneTaskPriority = 3u;
 
@@ skipping 728 matching lines @@
             *it, prepare_tiles_count_, &task);
     if (task)
       decode_tasks.push_back(task);
 
     if (need_to_unref_when_finished)
       ++it;
     else
       it = images.erase(it);
   }
 
-  return make_scoped_refptr(new RasterTaskImpl(
+  scoped_ptr<RasteringInfo> rastering_info = RasteringInfo::Create(
       tile_task_runner_, resource, prioritized_tile.raster_source(),
       tile->content_rect(), tile->invalidated_content_rect(),
       tile->contents_scale(), playback_settings,
       prioritized_tile.priority().resolution, tile->layer_id(),
       prepare_tiles_count_, static_cast<const void*>(tile), tile->id(),
       tile->invalidated_id(), resource_content_id, tile->source_frame_number(),
       base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
-                 tile->id(), resource),
-      &decode_tasks));
+                 tile->id(), resource));
+  return make_scoped_refptr(
+      new RasterTaskImpl(std::move(rastering_info), &decode_tasks));
 }
 
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     Resource* resource,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
   TileDrawInfo& draw_info = tile->draw_info();
@@ skipping 316 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc