cc: Made use color estimator a const instead of a flag.

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;

[piman, 2013/07/01 20:14:45]

nit: do we even need this?

[vmpstr, 2013/07/01 20:22:18]

I think it's still useful to disable the color estimator while debugging things
to force everything to do a texture upload. I'd prefer to keep it, instead of
remembering to set analysis_.is_solid_color to false around line 100...

+
 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>(
@@ skipping 18 matching lines @@
   }
 };
 
 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
   RasterWorkerPoolTaskImpl(const Resource* resource,
                            PicturePileImpl* picture_pile,
                            gfx::Rect content_rect,
                            float contents_scale,
                            RasterMode raster_mode,
-                           bool use_color_estimator,
                            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),
         metadata_(metadata),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
                  "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
                  "metadata",
                  TracedValue::FromValue(metadata_.AsValue().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 &= use_color_estimator_;
+    analysis_.is_solid_color &= kUseColorEstimator;
   }
 
   bool RunRasterOnThread(SkDevice* device, unsigned thread_index) {
     TRACE_EVENT2(
         "cc",
         "RasterWorkerPoolTaskImpl::RunRasterOnThread",
         "metadata",
         TracedValue::FromValue(metadata_.AsValue().release()),
         "raster_mode",
         TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
@@ skipping 64 matching lines @@
 
  protected:
   virtual ~RasterWorkerPoolTaskImpl() {}
 
  private:
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
   RasterMode raster_mode_;
-  bool use_color_estimator_;
   RasterTaskMetadata metadata_;
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
@@ skipping 218 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,
-    bool use_color_estimator,
     const RasterTaskMetadata& metadata,
     RenderingStatsInstrumentation* rendering_stats,
     const RasterTask::Reply& reply,
     Task::Set* dependencies) {
   return RasterTask(new RasterWorkerPoolTaskImpl(resource,
                                                  picture_pile,
                                                  content_rect,
                                                  contents_scale,
                                                  raster_mode,
-                                                 use_color_estimator,
                                                  metadata,
                                                  rendering_stats,
                                                  reply,
                                                  &dependencies->tasks_));
 }
 
 // static
 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
     skia::LazyPixelRef* pixel_ref,
     int layer_id,
@@ skipping 74 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