cc: Move worker threads to content.

cc/resources/picture_pile.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/picture_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "cc/base/region.h"
 #include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/tile_task_worker_pool.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 // Layout pixel buffer around the visible layer rect to record.  Any base
 // picture that intersects the visible layer rect expanded by this distance
 // will be recorded.
 const int kPixelDistanceToRecord = 8000;
 // We don't perform solid color analysis on images that have more than 10 skia
 // operations.
 const int kOpCountThatIsOkToAnalyze = 10;
@@ skipping 135 matching lines @@
 #endif
 
 }  // namespace
 
 namespace cc {
 
 PicturePile::PicturePile(float min_contents_scale,
                          const gfx::Size& tile_grid_size)
     : min_contents_scale_(0),
       slow_down_raster_scale_factor_for_debug_(0),
+      gather_pixel_refs_(false),
       has_any_recordings_(false),
       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
       requires_clear_(true),
       is_solid_color_(false),
       solid_color_(SK_ColorTRANSPARENT),
       background_color_(SK_ColorTRANSPARENT),
       pixel_record_distance_(kPixelDistanceToRecord),
       is_suitable_for_gpu_rasterization_(true) {
   tiling_.SetMaxTextureSize(gfx::Size(kBasePictureSize, kBasePictureSize));
   SetMinContentsScale(min_contents_scale);
@@ skipping 353 matching lines @@
 
 void PicturePile::CreatePictures(ContentLayerClient* painter,
                                  RecordingSource::RecordingMode recording_mode,
                                  const std::vector<gfx::Rect>& record_rects) {
   for (const auto& record_rect : record_rects) {
     gfx::Rect padded_record_rect = PadRect(record_rect);
 
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
     scoped_refptr<Picture> picture;
 
-    // Note: Currently, gathering of pixel refs when using a single
-    // raster thread doesn't provide any benefit. This might change
-    // in the future but we avoid it for now to reduce the cost of
-    // Picture::Create.
-    bool gather_pixel_refs = TileTaskWorkerPool::GetNumWorkerThreads() > 1;
-
     for (int i = 0; i < repeat_count; i++) {
       picture = Picture::Create(padded_record_rect, painter, tile_grid_size_,
-                                gather_pixel_refs, recording_mode);
+                                gather_pixel_refs_, recording_mode);
       // Note the '&&' with previous is-suitable state.
       // This means that once a picture-pile becomes unsuitable for gpu
       // rasterization due to some content, it will continue to be unsuitable
       // even if that content is replaced by gpu-friendly content.
       // This is an optimization to avoid iterating though all pictures in
       // the pile after each invalidation.
       if (is_suitable_for_gpu_rasterization_) {
         const char* reason = nullptr;
         is_suitable_for_gpu_rasterization_ &=
             picture->IsSuitableForGpuRasterization(&reason);
@@ skipping 55 matching lines @@
   int buffer_pixels = static_cast<int>(ceil(1 / min_contents_scale) - 1);
   buffer_pixels = std::max(0, buffer_pixels);
   SetBufferPixels(buffer_pixels);
   min_contents_scale_ = min_contents_scale;
 }
 
 void PicturePile::SetSlowdownRasterScaleFactor(int factor) {
   slow_down_raster_scale_factor_for_debug_ = factor;
 }
 
+void PicturePile::SetGatherPixelRefs(bool gather_pixel_refs) {
+  gather_pixel_refs_ = gather_pixel_refs;
+}
+
 void PicturePile::SetBackgroundColor(SkColor background_color) {
   background_color_ = background_color;
 }
 
 void PicturePile::SetRequiresClear(bool requires_clear) {
   requires_clear_ = requires_clear;
 }
 
 bool PicturePile::IsSuitableForGpuRasterization() const {
   return is_suitable_for_gpu_rasterization_;
@@ skipping 136 matching lines @@
 const Picture* PicturePile::PictureInfo::GetPicture() const {
   return picture_.get();
 }
 
 float PicturePile::PictureInfo::GetInvalidationFrequency() const {
   return invalidation_history_.count() /
          static_cast<float>(INVALIDATION_FRAMES_TRACKED);
 }
 
 }  // namespace cc