cc: Eliminate tile.h's dependency on tile_manager.h

cc/resources/raster_worker_pool.cc

 // Copyright 2013 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/raster_worker_pool.h"
 
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "skia/ext/lazy_pixel_ref.h"
 #include "skia/ext/paint_simplifier.h"
 
 namespace cc {
 
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
-scoped_ptr<base::Value> RasterModeAsValue(RasterMode raster_mode) {
-  switch (raster_mode) {
-    case HIGH_QUALITY_NO_LCD_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("HIGH_QUALITY_NO_LCD_RASTER_MODE"));
-    case HIGH_QUALITY_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("HIGH_QUALITY_RASTER_MODE"));
-    case LOW_QUALITY_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("LOW_QUALITY_RASTER_MODE"));
-    case NUM_RASTER_MODES:
-    default:
-      NOTREACHED() << "Unrecognized RasterMode value " << raster_mode;
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("<unknown RasterMode value>"));
-  }
-}
-
 class DisableLCDTextFilter : public SkDrawFilter {
  public:
   // SkDrawFilter interface.
   virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
     if (type != SkDrawFilter::kText_Type)
       return true;
 
     paint->setLCDRenderText(false);
     return true;
   }
 };
 
+scoped_ptr<base::Value> RasterTracingDataAsValue(
+    bool is_tile_in_pending_tree_now_bin_,
+    TileResolution tile_resolution_,
+    int layer_id_,
+    const void* tile_id_,
+    int source_frame_number_) {

[reveman, 2013/07/03 16:56:12]

no "_" suffixes please. however, I think this would be better as a non-static
private member function of RasterWorkerPoolTaskImpl.
RasterWorkerPoolTaskImpl::DataAsValue() or maybe even just AsValue().

[vmpstr, 2013/07/03 17:33:33]

Oops, sorry about the trailing underscores, it was a very automated change. I
moved this to be DataAsValue (I prefer to keep Data there, since we're not
returning all of the information about the task here)

+  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
+  res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release());
+  res->SetBoolean("is_tile_in_pending_tree_now_bin",
+                  is_tile_in_pending_tree_now_bin_);
+  res->Set("resolution", TileResolutionAsValue(tile_resolution_).release());
+  res->SetInteger("source_frame_number", source_frame_number_);
+  res->SetInteger("layer_id", layer_id_);
+  return res.PassAs<base::Value>();
+}
+
 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
   RasterWorkerPoolTaskImpl(const Resource* resource,
                            PicturePileImpl* picture_pile,
                            gfx::Rect content_rect,
                            float contents_scale,
                            RasterMode raster_mode,
-                           const RasterTaskMetadata& metadata,
+                           bool is_tile_in_pending_tree_now_bin,
+                           TileResolution tile_resolution,
+                           int layer_id,
+                           const void* tile_id,
+                           int source_frame_number,
                            RenderingStatsInstrumentation* rendering_stats,
                            const RasterWorkerPool::RasterTask::Reply& reply,
                            TaskVector* dependencies)
       : internal::RasterWorkerPoolTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
-        metadata_(metadata),
+        is_tile_in_pending_tree_now_bin_(is_tile_in_pending_tree_now_bin),
+        tile_resolution_(tile_resolution),
+        layer_id_(layer_id),
+        tile_id_(tile_id),
+        source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
                  "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
                  "metadata",

[reveman, 2013/07/03 16:56:12]

lets remove all references to metadata. "data" here is fine unless you can come
up with something better.

[vmpstr, 2013/07/03 17:33:33]

Done.

-                 TracedValue::FromValue(metadata_.AsValue().release()));
+                 TracedValue::FromValue(
+                     RasterTracingDataAsValue(is_tile_in_pending_tree_now_bin_,
+                                              tile_resolution_,
+                                              layer_id_,
+                                              tile_id_,
+                                              source_frame_number_).release()));
 
     DCHECK(picture_pile_.get());
     DCHECK(rendering_stats_);
 
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
     DCHECK(picture_clone);
 
     base::TimeTicks start_time = rendering_stats_->StartRecording();
     picture_clone->AnalyzeInRect(content_rect_, contents_scale_, &analysis_);
     base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
 
     // Record the solid color prediction.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
                           analysis_.is_solid_color);
     rendering_stats_->AddTileAnalysisResult(duration,
                                             analysis_.is_solid_color);
 
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
   bool RunRasterOnThread(SkDevice* device, unsigned thread_index) {
     TRACE_EVENT2(
         "cc",
         "RasterWorkerPoolTaskImpl::RunRasterOnThread",
         "metadata",
-        TracedValue::FromValue(metadata_.AsValue().release()),
+        TracedValue::FromValue(
+            RasterTracingDataAsValue(is_tile_in_pending_tree_now_bin_,
+                                     tile_resolution_,
+                                     layer_id_,
+                                     tile_id_,
+                                     source_frame_number_).release()),
         "raster_mode",
         TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
 
     devtools_instrumentation::ScopedLayerTask raster_task(
-        devtools_instrumentation::kRasterTask, metadata_.layer_id);
+        devtools_instrumentation::kRasterTask, layer_id_);
 
     DCHECK(picture_pile_.get());
     DCHECK(device);
 
     if (analysis_.is_solid_color)
       return false;
 
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
@@ skipping 17 matching lines @@
     canvas.setDrawFilter(draw_filter.get());
 
     if (rendering_stats_->record_rendering_stats()) {
       PicturePileImpl::RasterStats raster_stats;
       picture_clone->RasterToBitmap(
           &canvas, content_rect_, contents_scale_, &raster_stats);
       rendering_stats_->AddRaster(
           raster_stats.total_rasterize_time,
           raster_stats.best_rasterize_time,
           raster_stats.total_pixels_rasterized,
-          metadata_.is_tile_in_pending_tree_now_bin);
+          is_tile_in_pending_tree_now_bin_);
 
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           raster_stats.total_rasterize_time.InMicroseconds(),
           0,
           100000,
           100);
     } else {
       picture_clone->RasterToBitmap(
           &canvas, content_rect_, contents_scale_, NULL);
@@ skipping 13 matching lines @@
 
  protected:
   virtual ~RasterWorkerPoolTaskImpl() {}
 
  private:
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
   RasterMode raster_mode_;
-  RasterTaskMetadata metadata_;
+  bool is_tile_in_pending_tree_now_bin_;
+  TileResolution tile_resolution_;
+  int layer_id_;
+  const void* tile_id_;
+  int source_frame_number_;
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
                                 int layer_id,
@@ skipping 96 matching lines @@
   DCHECK(!did_complete_);
   did_complete_ = true;
 }
 
 bool RasterWorkerPoolTask::HasCompleted() const {
   return did_complete_;
 }
 
 }  // namespace internal
 
-scoped_ptr<base::Value> RasterTaskMetadata::AsValue() const {
-  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-  res->Set("tile_id", TracedValue::CreateIDRef(tile_id).release());
-  res->SetBoolean("is_tile_in_pending_tree_now_bin",
-                  is_tile_in_pending_tree_now_bin);
-  res->Set("resolution", TileResolutionAsValue(tile_resolution).release());
-  res->SetInteger("source_frame_number", source_frame_number);
-  return res.PassAs<base::Value>();
-}
-
 RasterWorkerPool::Task::Set::Set() {
 }
 
 RasterWorkerPool::Task::Set::~Set() {
 }
 
 void RasterWorkerPool::Task::Set::Insert(const Task& task) {
   DCHECK(!task.is_null());
   tasks_.push_back(task.internal_);
 }
@@ skipping 91 matching lines @@
   graph_.set(raster_task, raster_node.Pass());
 }
 
 // static
 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     const Resource* resource,
     PicturePileImpl* picture_pile,
     gfx::Rect content_rect,
     float contents_scale,
     RasterMode raster_mode,
-    const RasterTaskMetadata& metadata,
+    bool is_tile_in_pending_tree_now_bin,
+    TileResolution tile_resolution,
+    int layer_id,
+    const void* tile_id,
+    int source_frame_number,
     RenderingStatsInstrumentation* rendering_stats,
     const RasterTask::Reply& reply,
     Task::Set* dependencies) {
-  return RasterTask(new RasterWorkerPoolTaskImpl(resource,
-                                                 picture_pile,
-                                                 content_rect,
-                                                 contents_scale,
-                                                 raster_mode,
-                                                 metadata,
-                                                 rendering_stats,
-                                                 reply,
-                                                 &dependencies->tasks_));
+  return RasterTask(
+      new RasterWorkerPoolTaskImpl(resource,
+                                   picture_pile,
+                                   content_rect,
+                                   contents_scale,
+                                   raster_mode,
+                                   is_tile_in_pending_tree_now_bin,
+                                   tile_resolution,
+                                   layer_id,
+                                   tile_id,
+                                   source_frame_number,
+                                   rendering_stats,
+                                   reply,
+                                   &dependencies->tasks_));
 }
 
 // static
 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
     skia::LazyPixelRef* pixel_ref,
     int layer_id,
     RenderingStatsInstrumentation* stats_instrumentation,
     const Task::Reply& reply) {
   return Task(new ImageDecodeWorkerPoolTaskImpl(pixel_ref,
                                                 layer_id,
@@ skipping 70 matching lines @@
   TRACE_EVENT1("cc", "RasterWorkerPool::OnRasterFinished",
                "schedule_raster_tasks_count", schedule_raster_tasks_count);
   DCHECK_GE(schedule_raster_tasks_count_, schedule_raster_tasks_count);
   // Call OnRasterTasksFinished() when we've finished running all raster
   // tasks needed since last time SetRasterTaskGraph() was called.
   if (schedule_raster_tasks_count_ == schedule_raster_tasks_count)
     OnRasterTasksFinished();
 }
 
 }  // namespace cc