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"
@@ skipping 17 matching lines @@
     return true;
   }
 };
 
 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
   RasterWorkerPoolTaskImpl(const Resource* resource,
                            PicturePileImpl* picture_pile,
                            gfx::Rect content_rect,
                            float contents_scale,
                            RasterMode raster_mode,

[reveman, 2013/06/30 05:47:50]

how about we just pass a SkDrawFilter* instead of a raster mode? we could then
move the definition of RasterTask back to the tile manager as TileRasterMode.

[vmpstr, 2013/07/01 18:41:37]

As it stands right now, TileManager isn't even aware that we're using skia since
all of the actual raster code is in the rwp and picture_pile_impl. I think it
would look a bit clumsy if we create a SkDrawFilter in tile manager, pass that
along, then create SkCanvas and attach the given filter. I very much prefer
passing the intent (such as a raster mode), instead of passing a particular
implementation (such as SkDrawFilter). We could pass two bools, like use lcd and
use low quality. However, I think raster mode is the right kind of abstraction
in this case... Wdyt?

                            bool use_color_estimator,

[reveman, 2013/06/30 05:47:50]

this is the same for every task. how about we move this property to the
PicturePileImpl instead?

[vmpstr, 2013/07/01 18:41:37]

This will be removed in https://codereview.chromium.org/18370002/

                            const RasterTaskMetadata& metadata,
                            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),
         use_color_estimator_(use_color_estimator),
@@ skipping 10 matching lines @@
     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);

[reveman, 2013/06/30 05:47:50]

can we make this consistent with raster and add PicturePileImpl::AnalysisStats?

[vmpstr, 2013/07/01 18:41:37]

This is RenderingStatsInstrumentation (which is a big class)... It would be
quite a big change to add a parallel class for analysis. Do you think it's worth
it? Maybe just rename the variable here to mean something better?

 
     // Record the solid color prediction.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
                           analysis_.is_solid_color);

[reveman, 2013/06/30 05:47:50]

maybe move this to TileManager

[vmpstr, 2013/07/01 18:41:37]

Removed in a different CL.

     rendering_stats_->AddTileAnalysisResult(duration,
                                             analysis_.is_solid_color);

[reveman, 2013/06/30 05:47:50]

btw, s/AddTileAnalysisResult/AddAnalysisResult/ or move this to TileManager

[vmpstr, 2013/07/01 18:41:37]

Done.

 
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= use_color_estimator_;
   }
 
   bool RunRasterOnThread(SkDevice* device, unsigned thread_index) {
     TRACE_EVENT1(
         "cc", "RasterWorkerPoolTaskImpl::RunRasterOnThread",
         "metadata", TracedValue::FromValue(metadata_.AsValue().release()));

[reveman, 2013/06/30 05:47:50]

do we need all that data in this trace event? can some of it be moved to
TileManager::OnRasterTaskCompleted?

[vmpstr, 2013/07/01 18:41:37]

I think having this information on RunRasterOnThread is more useful than
OnRasterTaskCompleted for me. When I look at traces, and I look for what data is
associated with a tile, it's a lot easier for me to check the RunRasterOnThread
slice instead of the (much smaller, and on a different thread)
OnRasterTaskCompleted... That being said, I usually just use this information:
resolution, is tile in pending tree now bin, and raster mode (this isn't a part
of the metadata, but a separate parameter). It's not everything, but I think
that's most of it.

     devtools_instrumentation::ScopedLayerTask raster_task(
         devtools_instrumentation::kRasterTask, metadata_.layer_id);
 
     DCHECK(picture_pile_.get());
     DCHECK(device);
 
     if (analysis_.is_solid_color)
       return false;
 
     PicturePileImpl* picture_clone =
@@ skipping 12 matching lines @@
       case HIGH_QUALITY_RASTER_MODE:
         break;
       case NUM_RASTER_MODES:
       default:
         NOTREACHED();
     }
 
     canvas.setDrawFilter(draw_filter.get());
 
     if (rendering_stats_->record_rendering_stats()) {
       PicturePileImpl::RasterStats raster_stats;

[reveman, 2013/06/30 05:47:50]

How about we remove |rendering_stats_| and add these parameters to
RasterWorkerPoolTaskImpl ctor:
PicturePileImpl::RasterStats* raster_stats,
PicturePileImpl::AnalysisStats* analysis_stats

that way all this logic can go into the tile manager.

[vmpstr, 2013/07/01 18:41:37]

It only really gets the time it takes to run the function (in analysis, I mean).
I can make this just a float parameter. Or do you prefer a struct?

       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);
 
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
@@ skipping 133 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 196 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