cc/resources/display_list_raster_source.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/display_list_raster_source.h"
   6
   7 #include "base/trace_event/trace_event.h"
   8 #include "cc/base/region.h"
   9 #include "cc/debug/debug_colors.h"
  10 #include "cc/resources/display_item_list.h"
  11 #include "cc/resources/raster_source_helper.h"
  12 #include "skia/ext/analysis_canvas.h"
  13 #include "third_party/skia/include/core/SkCanvas.h"
  14 #include "third_party/skia/include/core/SkPictureRecorder.h"
  15 #include "ui/gfx/geometry/rect_conversions.h"
  16
  17 namespace {
  18
  19 #ifdef NDEBUG
  20 const bool kDefaultClearCanvasSetting = false;
  21 #else
  22 const bool kDefaultClearCanvasSetting = true;
  23 #endif
  24
  25 }  // namespace
  26
  27 namespace cc {
  28
  29 scoped_refptr<DisplayListRasterSource>
  30 DisplayListRasterSource::CreateFromDisplayListRecordingSource(
  31     const DisplayListRecordingSource* other,
  32     bool can_use_lcd_text) {
  33   return make_scoped_refptr(
  34       new DisplayListRasterSource(other, can_use_lcd_text));
  35 }
  36
  37 DisplayListRasterSource::DisplayListRasterSource()
  38     : background_color_(SK_ColorTRANSPARENT),
  39       requires_clear_(true),
  40       can_use_lcd_text_(true),
  41       is_solid_color_(false),
  42       solid_color_(SK_ColorTRANSPARENT),
  43       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
  44       slow_down_raster_scale_factor_for_debug_(0),
  45       should_attempt_to_use_distance_field_text_(false) {
  46 }
  47
  48 DisplayListRasterSource::DisplayListRasterSource(
  49     const DisplayListRecordingSource* other,
  50     bool can_use_lcd_text)
  51     : display_list_(other->display_list_),
  52       background_color_(other->background_color_),
  53       requires_clear_(other->requires_clear_),
  54       can_use_lcd_text_(can_use_lcd_text),
  55       is_solid_color_(other->is_solid_color_),
  56       solid_color_(other->solid_color_),
  57       recorded_viewport_(other->recorded_viewport_),
  58       size_(other->size_),
  59       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
  60       slow_down_raster_scale_factor_for_debug_(
  61           other->slow_down_raster_scale_factor_for_debug_),
  62       should_attempt_to_use_distance_field_text_(false) {
  63 }
  64
  65 DisplayListRasterSource::DisplayListRasterSource(
  66     const DisplayListRasterSource* other,
  67     bool can_use_lcd_text)
  68     : display_list_(other->display_list_),
  69       background_color_(other->background_color_),
  70       requires_clear_(other->requires_clear_),
  71       can_use_lcd_text_(can_use_lcd_text),
  72       is_solid_color_(other->is_solid_color_),
  73       solid_color_(other->solid_color_),
  74       recorded_viewport_(other->recorded_viewport_),
  75       size_(other->size_),
  76       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
  77       slow_down_raster_scale_factor_for_debug_(
  78           other->slow_down_raster_scale_factor_for_debug_),
  79       should_attempt_to_use_distance_field_text_(
  80           other->should_attempt_to_use_distance_field_text_) {
  81 }
  82
  83 DisplayListRasterSource::~DisplayListRasterSource() {
  84 }
  85
  86 void DisplayListRasterSource::PlaybackToSharedCanvas(
  87     SkCanvas* canvas,
  88     const gfx::Rect& canvas_rect,
  89     float contents_scale) const {
  90   RasterCommon(canvas, NULL, canvas_rect, contents_scale);
  91 }
  92
  93 void DisplayListRasterSource::RasterForAnalysis(skia::AnalysisCanvas* canvas,
  94                                                 const gfx::Rect& canvas_rect,
  95                                                 float contents_scale) const {
  96   RasterCommon(canvas, canvas, canvas_rect, contents_scale);
  97 }
  98
  99 void DisplayListRasterSource::PlaybackToCanvas(SkCanvas* canvas,
 100                                                const gfx::Rect& canvas_rect,
 101                                                float contents_scale) const {
 102   RasterSourceHelper::PrepareForPlaybackToCanvas(
 103       canvas, canvas_rect, gfx::Rect(size_), contents_scale, background_color_,
 104       clear_canvas_with_debug_color_, requires_clear_);
 105
 106   RasterCommon(canvas, NULL, canvas_rect, contents_scale);
 107 }
 108
 109 void DisplayListRasterSource::RasterCommon(SkCanvas* canvas,
 110                                            SkDrawPictureCallback* callback,
 111                                            const gfx::Rect& canvas_rect,
 112                                            float contents_scale) const {
 113   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
 114   gfx::Rect content_rect =
 115       gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(size_), contents_scale));
 116   content_rect.Intersect(canvas_rect);
 117
 118   canvas->clipRect(gfx::RectToSkRect(content_rect), SkRegion::kIntersect_Op);
 119
 120   DCHECK(display_list_.get());
 121   display_list_->Raster(canvas, callback, contents_scale);
 122 }
 123
 124 skia::RefPtr<SkPicture> DisplayListRasterSource::GetFlattenedPicture() {
 125   TRACE_EVENT0("cc", "DisplayListRasterSource::GetFlattenedPicture");
 126
 127   gfx::Rect display_list_rect(size_);
 128   SkPictureRecorder recorder;
 129   SkCanvas* canvas = recorder.beginRecording(display_list_rect.width(),
 130                                              display_list_rect.height());
 131   if (!display_list_rect.IsEmpty())
 132     PlaybackToCanvas(canvas, display_list_rect, 1.0);
 133   skia::RefPtr<SkPicture> picture =
 134       skia::AdoptRef(recorder.endRecordingAsPicture());
 135
 136   return picture;
 137 }
 138
 139 size_t DisplayListRasterSource::GetPictureMemoryUsage() const {
 140   return display_list_->PictureMemoryUsage();
 141 }
 142
 143 void DisplayListRasterSource::PerformSolidColorAnalysis(
 144     const gfx::Rect& content_rect,
 145     float contents_scale,
 146     RasterSource::SolidColorAnalysis* analysis) const {
 147   DCHECK(analysis);
 148   TRACE_EVENT0("cc", "DisplayListRasterSource::PerformSolidColorAnalysis");
 149
 150   gfx::Rect layer_rect =
 151       gfx::ScaleToEnclosingRect(content_rect, 1.0f / contents_scale);
 152
 153   layer_rect.Intersect(gfx::Rect(size_));
 154   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
 155   RasterForAnalysis(&canvas, layer_rect, 1.0f);
 156   analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
 157 }
 158
 159 void DisplayListRasterSource::GatherPixelRefs(
 160     const gfx::Rect& content_rect,
 161     float contents_scale,
 162     std::vector<SkPixelRef*>* pixel_refs) const {
 163   DCHECK_EQ(0u, pixel_refs->size());
 164
 165   gfx::Rect layer_rect =
 166       gfx::ScaleToEnclosingRect(content_rect, 1.0f / contents_scale);
 167
 168   PixelRefMap::Iterator iterator(layer_rect, display_list_.get());
 169   while (iterator) {
 170     pixel_refs->push_back(*iterator);
 171     ++iterator;
 172   }
 173 }
 174
 175 bool DisplayListRasterSource::CoversRect(const gfx::Rect& content_rect,
 176                                          float contents_scale) const {
 177   if (size_.IsEmpty())
 178     return false;
 179   gfx::Rect layer_rect =
 180       gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale);
 181   layer_rect.Intersect(gfx::Rect(size_));
 182
 183   return recorded_viewport_.Contains(layer_rect);
 184 }
 185
 186 gfx::Size DisplayListRasterSource::GetSize() const {
 187   return size_;
 188 }
 189
 190 bool DisplayListRasterSource::IsSolidColor() const {
 191   return is_solid_color_;
 192 }
 193
 194 SkColor DisplayListRasterSource::GetSolidColor() const {
 195   DCHECK(IsSolidColor());
 196   return solid_color_;
 197 }
 198
 199 bool DisplayListRasterSource::HasRecordings() const {
 200   return !!display_list_.get();
 201 }
 202
 203 void DisplayListRasterSource::SetShouldAttemptToUseDistanceFieldText() {
 204   should_attempt_to_use_distance_field_text_ = true;
 205 }
 206
 207 bool DisplayListRasterSource::ShouldAttemptToUseDistanceFieldText() const {
 208   return should_attempt_to_use_distance_field_text_;
 209 }
 210
 211 void DisplayListRasterSource::AsValueInto(
 212     base::trace_event::TracedValue* array) const {
 213   if (display_list_.get())
 214     TracedValue::AppendIDRef(display_list_.get(), array);
 215 }
 216
 217 void DisplayListRasterSource::DidBeginTracing() {
 218   if (display_list_.get())
 219     display_list_->EmitTraceSnapshot();
 220 }
 221
 222 bool DisplayListRasterSource::CanUseLCDText() const {
 223   return can_use_lcd_text_;
 224 }
 225
 226 scoped_refptr<RasterSource> DisplayListRasterSource::CreateCloneWithoutLCDText()
 227     const {
 228   bool can_use_lcd_text = false;
 229   return scoped_refptr<RasterSource>(
 230       new DisplayListRasterSource(this, can_use_lcd_text));
 231 }
 232
 233 }  // namespace cc