cc: Combine analysis and raster

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"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/utils/SkNWayCanvas.h"
+#include "ui/gfx/skia_util.h"
 
 namespace cc {
 
 namespace {
 
 // Subclass of Allocator that takes a suitably allocated pointer and uses
 // it as the pixel memory for the bitmap.
 class IdentityAllocator : public SkBitmap::Allocator {
  public:
   explicit IdentityAllocator(void* buffer) : buffer_(buffer) {}
   virtual bool allocPixelRef(SkBitmap* dst, SkColorTable*) OVERRIDE {
     dst->setPixels(buffer_);
     return true;
   }
  private:
   void* buffer_;
 };
 
-// Flag to indicate whether we should try and detect that
-// a tile is of solid color.
-const bool kUseColorEstimator = true;
-
 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;
   }
@@ skipping 18 matching lines @@
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
         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",
-                 "data",
-                 TracedValue::FromValue(DataAsValue().release()));
-
-    DCHECK(picture_pile_.get());
-    DCHECK(rendering_stats_);
-
-    PicturePileImpl* picture_clone =
-        picture_pile_->GetCloneForDrawingOnThread(thread_index);
-
-    DCHECK(picture_clone);
-
-    picture_clone->AnalyzeInRect(content_rect_, contents_scale_, &analysis_);
-
-    // Record the solid color prediction.
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
-                          analysis_.is_solid_color);
-
-    // Clear the flag if we're not using the estimator.
-    analysis_.is_solid_color &= kUseColorEstimator;
-  }
-
-  bool RunRasterOnThread(unsigned thread_index,
-                         void* buffer,
-                         gfx::Size size,
-                         int stride) {
+  // Overridden from internal::RasterWorkerPoolTask:
+  virtual bool RunOnWorkerThread(unsigned thread_index,
+                                 void* buffer,
+                                 gfx::Size size,
+                                 int stride) OVERRIDE {
     TRACE_EVENT2(
         "cc", "RasterWorkerPoolTaskImpl::RunRasterOnThread",
         "data",
         TracedValue::FromValue(DataAsValue().release()),
         "raster_mode",
         TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
 
     devtools_instrumentation::ScopedLayerTask raster_task(
         devtools_instrumentation::kRasterTask, layer_id_);
 
     DCHECK(picture_pile_.get());
     DCHECK(buffer);
 
-    if (analysis_.is_solid_color)
-      return false;
-
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
     SkBitmap bitmap;
     switch (resource()->format()) {
       case RGBA_4444:
         // Use the default stride if we will eventually convert this
         // bitmap to 4444.
         bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                          size.width(),
                          size.height());
         bitmap.allocPixels();
         break;
       case RGBA_8888:
       case BGRA_8888:
         bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                          size.width(),
                          size.height(),
                          stride);
         bitmap.setPixels(buffer);
         break;
       case LUMINANCE_8:
       case RGB_565:
       case ETC1:
         NOTREACHED();
         break;
     }
 
-    SkBitmapDevice device(bitmap);
-    SkCanvas canvas(&device);
+    SkBitmap empty_bitmap;
+    empty_bitmap.setConfig(
+        SkBitmap::kNo_Config, content_rect_.width(), content_rect_.height());
+    gfx::Rect analysis_rect(
+        picture_clone->AnalysisRectForRaster(content_rect_, contents_scale_));
+    skia::AnalysisDevice analysis_device(empty_bitmap,
+                                         gfx::RectToSkRect(analysis_rect));
+    skia::AnalysisCanvas analysis_canvas(&analysis_device);
+
+    SkBitmapDevice raster_device(bitmap);
+    SkCanvas raster_canvas(&raster_device);
+
+    SkNWayCanvas canvas(content_rect_.width(), content_rect_.height());
+    canvas.addCanvas(&analysis_canvas);
+    canvas.addCanvas(&raster_canvas);
+
     skia::RefPtr<SkDrawFilter> draw_filter;
     switch (raster_mode_) {
       case LOW_QUALITY_RASTER_MODE:
         draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
         break;
       case HIGH_QUALITY_NO_LCD_RASTER_MODE:
         draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
         break;
       case HIGH_QUALITY_RASTER_MODE:
         break;
@@ skipping 25 matching lines @@
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           100000,
           100);
     }
 
     ChangeBitmapConfigIfNeeded(bitmap, buffer);
 
-    return true;
+    analysis_.is_solid_color =
+        analysis_canvas.GetColorIfSolid(&analysis_.solid_color);
+    analysis_.has_text = analysis_canvas.HasText();
+
+    // Record the solid color prediction.
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
+                          analysis_.is_solid_color);
+
+    return !analysis_.is_solid_color;
   }
 
-  // Overridden from internal::RasterWorkerPoolTask:
-  virtual bool RunOnWorkerThread(unsigned thread_index,
-                                 void* buffer,
-                                 gfx::Size size,
-                                 int stride)
-      OVERRIDE {
-    RunAnalysisOnThread(thread_index);
-    return RunRasterOnThread(thread_index, buffer, size, stride);
-  }
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(analysis_, !HasFinishedRunning() || WasCanceled());
   }
 
  protected:
   virtual ~RasterWorkerPoolTaskImpl() {}
 
  private:
   scoped_ptr<base::Value> DataAsValue() const {
     scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
@@ skipping 369 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc