cc: Combine analysis and raster

cc/resources/picture_pile_impl.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 <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
@@ skipping 56 matching lines @@
   CHECK_GT(clones_for_drawing_.clones_.size(), thread_index);
   return clones_for_drawing_.clones_[thread_index].get();
 }
 
 void PicturePileImpl::RasterDirect(
     SkCanvas* canvas,
     gfx::Rect canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   RasterCommon(canvas,
-               NULL,
                canvas_rect,
                contents_scale,
                rendering_stats_instrumentation);
 }
 
-void PicturePileImpl::RasterForAnalysis(
-    skia::AnalysisCanvas* canvas,
-    gfx::Rect canvas_rect,
-    float contents_scale) {
-  RasterCommon(canvas, canvas, canvas_rect, contents_scale, NULL);
-}
-
 void PicturePileImpl::RasterToBitmap(
     SkCanvas* canvas,
     gfx::Rect canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   if (clear_canvas_with_debug_color_) {
     // Any non-painted areas will be left in this color.
     canvas->clear(DebugColors::NonPaintedFillColor());
   }
 
@@ skipping 28 matching lines @@
       canvas->clipRect(gfx::RectToSkRect(inflated_content_rect),
                        SkRegion::kReplace_Op);
       canvas->clipRect(gfx::RectToSkRect(deflated_content_rect),
                        SkRegion::kDifference_Op);
       canvas->drawColor(background_color_, SkXfermode::kSrc_Mode);
       canvas->restore();
     }
   }
 
   RasterCommon(canvas,
-               NULL,
                canvas_rect,
                contents_scale,
                rendering_stats_instrumentation);
 }
 
 void PicturePileImpl::CoalesceRasters(gfx::Rect canvas_rect,
                                       gfx::Rect content_rect,
                                       float contents_scale,
                                       PictureRegionMap* results) {
   DCHECK(results);
@@ skipping 45 matching lines @@
       continue;
     }
 
     Region& region = it->second;
     region.Subtract(content_clip);
   }
 }
 
 void PicturePileImpl::RasterCommon(
     SkCanvas* canvas,
-    SkDrawPictureCallback* callback,
     gfx::Rect canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   DCHECK(contents_scale >= min_contents_scale_);
 
   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
   gfx::SizeF total_content_size = gfx::ScaleSize(tiling_.total_size(),
                                                  contents_scale);
   gfx::Rect total_content_rect(gfx::ToCeiledSize(total_content_size));
   gfx::Rect content_rect = total_content_rect;
@@ skipping 28 matching lines @@
         base::TimeDelta::FromInternalValue(std::numeric_limits<int64>::max());
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
     int rasterized_pixel_count = 0;
 
     for (int j = 0; j < repeat_count; ++j) {
       base::TimeTicks start_time;
       if (rendering_stats_instrumentation)
         start_time = rendering_stats_instrumentation->StartRecording();
 
       rasterized_pixel_count = picture->Raster(
-          canvas, callback, negated_clip_region, contents_scale);
+          canvas, negated_clip_region, contents_scale);
 
       if (rendering_stats_instrumentation) {
         base::TimeDelta duration =
             rendering_stats_instrumentation->EndRecording(start_time);
         best_duration = std::min(best_duration, duration);
       }
     }
 
     if (rendering_stats_instrumentation) {
       rendering_stats_instrumentation->AddRaster(best_duration,
@@ skipping 26 matching lines @@
       layer_rect.width(),
       layer_rect.height(),
       SkPicture::kUsePathBoundsForClip_RecordingFlag);
 
   RasterToBitmap(canvas, layer_rect, 1.0, NULL);
   picture->endRecording();
 
   return picture;
 }
 
-void PicturePileImpl::AnalyzeInRect(gfx::Rect content_rect,
-                                    float contents_scale,
-                                    PicturePileImpl::Analysis* analysis) {
-  DCHECK(analysis);
-  TRACE_EVENT0("cc", "PicturePileImpl::AnalyzeInRect");
-
-  gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
-      content_rect, 1.0f / contents_scale);
-
-  layer_rect.Intersect(gfx::Rect(tiling_.total_size()));
-
-  SkBitmap empty_bitmap;
-  empty_bitmap.setConfig(SkBitmap::kNo_Config,
-                         layer_rect.width(),
-                         layer_rect.height());
-  skia::AnalysisDevice device(empty_bitmap);
-  skia::AnalysisCanvas canvas(&device);
-
-  RasterForAnalysis(&canvas, layer_rect, 1.0f);
-
-  analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
-  analysis->has_text = canvas.HasText();
-}
-
 PicturePileImpl::Analysis::Analysis()
     : is_solid_color(false),
       has_text(false) {
 }
 
 PicturePileImpl::Analysis::~Analysis() {
 }
 
 PicturePileImpl::PixelRefIterator::PixelRefIterator(
     gfx::Rect content_rect,
@@ skipping 35 matching lines @@
     if (!picture || (processed_pictures_.count(picture) != 0))
       continue;
 
     processed_pictures_.insert(picture);
     pixel_ref_iterator_ = Picture::PixelRefIterator(layer_rect_, picture);
     if (pixel_ref_iterator_)
       break;
   }
 }
 
+gfx::Rect PicturePileImpl::AnalysisRectForRaster(gfx::Rect content_rect,
+                                                 float contents_scale) const {
+  // Bound the analysis rect to just the pile content.
+  gfx::Rect content_bounds(
+      gfx::ScaleToEnclosingRect(gfx::Rect(size()), contents_scale));
+  gfx::Rect analysis_rect(content_rect);
+  analysis_rect.Intersect(content_bounds);
+  // Move to canvas space.
+  analysis_rect.set_origin(gfx::Point());
+
+  return analysis_rect;
+}
+
 void PicturePileImpl::DidBeginTracing() {
   gfx::Rect layer_rect(tiling_.total_size());
   std::set<void*> processed_pictures;
   for (PictureMap::iterator it = picture_map_.begin();
        it != picture_map_.end();
        ++it) {
     Picture* picture = it->second.picture.get();
     if (picture && (processed_pictures.count(picture) == 0)) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc