cc/blink/web_display_item_list_impl.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/blink/web_display_item_list_impl.h"
   6
   7 #include <vector>
   8
   9 #include "cc/blink/web_filter_operations_impl.h"
  10 #include "cc/playback/clip_display_item.h"
  11 #include "cc/playback/clip_path_display_item.h"
  12 #include "cc/playback/compositing_display_item.h"
  13 #include "cc/playback/display_item_list_settings.h"
  14 #include "cc/playback/drawing_display_item.h"
  15 #include "cc/playback/filter_display_item.h"
  16 #include "cc/playback/float_clip_display_item.h"
  17 #include "cc/playback/transform_display_item.h"
  18 #include "skia/ext/refptr.h"
  19 #include "third_party/WebKit/public/platform/WebFloatRect.h"
  20 #include "third_party/WebKit/public/platform/WebRect.h"
  21 #include "third_party/skia/include/core/SkColorFilter.h"
  22 #include "third_party/skia/include/core/SkPicture.h"
  23 #include "third_party/skia/include/utils/SkMatrix44.h"
  24 #include "ui/gfx/geometry/safe_integer_conversions.h"
  25 #include "ui/gfx/transform.h"
  26
  27 namespace cc_blink {
  28
  29 namespace {
  30
  31 scoped_refptr<cc::DisplayItemList> CreateUncachedDisplayItemListForBlink() {
  32   cc::DisplayItemListSettings settings;
  33   settings.use_cached_picture = false;
  34   gfx::Rect layer_rect;
  35   return cc::DisplayItemList::Create(layer_rect, settings);
  36 }
  37
  38 }  // namespace
  39
  40 WebDisplayItemListImpl::WebDisplayItemListImpl()
  41     : display_item_list_(CreateUncachedDisplayItemListForBlink()) {
  42 }
  43
  44 WebDisplayItemListImpl::WebDisplayItemListImpl(
  45     cc::DisplayItemList* display_list)
  46     : display_item_list_(display_list) {
  47 }
  48
  49 void WebDisplayItemListImpl::appendDrawingItem(const SkPicture* picture) {
  50   if (display_item_list_->RetainsIndividualDisplayItems()) {
  51     auto* item =
  52         display_item_list_->CreateAndAppendItem<cc::DrawingDisplayItem>();
  53     item->SetNew(skia::SharePtr(const_cast<SkPicture*>(picture)));
  54   } else {
  55     cc::DrawingDisplayItem item;
  56     item.SetNew(skia::SharePtr(const_cast<SkPicture*>(picture)));
  57     display_item_list_->RasterIntoCanvas(item);
  58   }
  59 }
  60
  61 void WebDisplayItemListImpl::appendClipItem(
  62     const blink::WebRect& clip_rect,
  63     const blink::WebVector<SkRRect>& rounded_clip_rects) {
  64   std::vector<SkRRect> rounded_rects;
  65   for (size_t i = 0; i < rounded_clip_rects.size(); ++i) {
  66     rounded_rects.push_back(rounded_clip_rects[i]);
  67   }
  68   if (display_item_list_->RetainsIndividualDisplayItems()) {
  69     auto* item = display_item_list_->CreateAndAppendItem<cc::ClipDisplayItem>();
  70     item->SetNew(clip_rect, rounded_rects);
  71   } else {
  72     cc::ClipDisplayItem item;
  73     item.SetNew(clip_rect, rounded_rects);
  74     display_item_list_->RasterIntoCanvas(item);
  75   }
  76 }
  77
  78 void WebDisplayItemListImpl::appendEndClipItem() {
  79   if (display_item_list_->RetainsIndividualDisplayItems()) {
  80     display_item_list_->CreateAndAppendItem<cc::EndClipDisplayItem>();
  81   } else {
  82     display_item_list_->RasterIntoCanvas(cc::EndClipDisplayItem());
  83   }
  84 }
  85
  86 void WebDisplayItemListImpl::appendClipPathItem(const SkPath& clip_path,
  87                                                 SkRegion::Op clip_op,
  88                                                 bool antialias) {
  89   if (display_item_list_->RetainsIndividualDisplayItems()) {
  90     auto* item =
  91         display_item_list_->CreateAndAppendItem<cc::ClipPathDisplayItem>();
  92     item->SetNew(clip_path, clip_op, antialias);
  93   } else {
  94     cc::ClipPathDisplayItem item;
  95     item.SetNew(clip_path, clip_op, antialias);
  96     display_item_list_->RasterIntoCanvas(item);
  97   }
  98 }
  99
 100 void WebDisplayItemListImpl::appendEndClipPathItem() {
 101   if (display_item_list_->RetainsIndividualDisplayItems()) {
 102     display_item_list_->CreateAndAppendItem<cc::EndClipPathDisplayItem>();
 103   } else {
 104     display_item_list_->RasterIntoCanvas(cc::EndClipPathDisplayItem());
 105   }
 106 }
 107
 108 void WebDisplayItemListImpl::appendFloatClipItem(
 109     const blink::WebFloatRect& clip_rect) {
 110   if (display_item_list_->RetainsIndividualDisplayItems()) {
 111     auto* item =
 112         display_item_list_->CreateAndAppendItem<cc::FloatClipDisplayItem>();
 113     item->SetNew(clip_rect);
 114   } else {
 115     cc::FloatClipDisplayItem item;
 116     item.SetNew(clip_rect);
 117     display_item_list_->RasterIntoCanvas(item);
 118   }
 119 }
 120
 121 void WebDisplayItemListImpl::appendEndFloatClipItem() {
 122   if (display_item_list_->RetainsIndividualDisplayItems()) {
 123     display_item_list_->CreateAndAppendItem<cc::EndFloatClipDisplayItem>();
 124   } else {
 125     display_item_list_->RasterIntoCanvas(cc::EndFloatClipDisplayItem());
 126   }
 127 }
 128
 129 void WebDisplayItemListImpl::appendTransformItem(const SkMatrix44& matrix) {
 130   gfx::Transform transform;
 131   transform.matrix() = matrix;
 132
 133   if (display_item_list_->RetainsIndividualDisplayItems()) {
 134     auto* item =
 135         display_item_list_->CreateAndAppendItem<cc::TransformDisplayItem>();
 136     item->SetNew(transform);
 137   } else {
 138     cc::TransformDisplayItem item;
 139     item.SetNew(transform);
 140     display_item_list_->RasterIntoCanvas(item);
 141   }
 142 }
 143
 144 void WebDisplayItemListImpl::appendEndTransformItem() {
 145   if (display_item_list_->RetainsIndividualDisplayItems()) {
 146     display_item_list_->CreateAndAppendItem<cc::EndTransformDisplayItem>();
 147   } else {
 148     display_item_list_->RasterIntoCanvas(cc::EndTransformDisplayItem());
 149   }
 150 }
 151
 152 void WebDisplayItemListImpl::appendCompositingItem(
 153     float opacity,
 154     SkXfermode::Mode xfermode,
 155     SkRect* bounds,
 156     SkColorFilter* color_filter) {
 157   DCHECK_GE(opacity, 0.f);
 158   DCHECK_LE(opacity, 1.f);
 159   // TODO(ajuma): This should really be rounding instead of flooring the alpha
 160   // value, but that breaks slimming paint reftests.
 161
 162   if (display_item_list_->RetainsIndividualDisplayItems()) {
 163     auto* item =
 164         display_item_list_->CreateAndAppendItem<cc::CompositingDisplayItem>();
 165     item->SetNew(static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)),
 166                  xfermode, bounds, skia::SharePtr(color_filter));
 167   } else {
 168     cc::CompositingDisplayItem item;
 169     item.SetNew(static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)),
 170                 xfermode, bounds, skia::SharePtr(color_filter));
 171     display_item_list_->RasterIntoCanvas(item);
 172   }
 173 }
 174
 175 void WebDisplayItemListImpl::appendEndCompositingItem() {
 176   if (display_item_list_->RetainsIndividualDisplayItems()) {
 177     display_item_list_->CreateAndAppendItem<cc::EndCompositingDisplayItem>();
 178   } else {
 179     display_item_list_->RasterIntoCanvas(cc::EndCompositingDisplayItem());
 180   }
 181 }
 182
 183 void WebDisplayItemListImpl::appendFilterItem(
 184     const blink::WebFilterOperations& filters,
 185     const blink::WebFloatRect& bounds) {
 186   const WebFilterOperationsImpl& filters_impl =
 187       static_cast<const WebFilterOperationsImpl&>(filters);
 188
 189   if (display_item_list_->RetainsIndividualDisplayItems()) {
 190     auto* item =
 191         display_item_list_->CreateAndAppendItem<cc::FilterDisplayItem>();
 192     item->SetNew(filters_impl.AsFilterOperations(), bounds);
 193   } else {
 194     cc::FilterDisplayItem item;
 195     item.SetNew(filters_impl.AsFilterOperations(), bounds);
 196     display_item_list_->RasterIntoCanvas(item);
 197   }
 198 }
 199
 200 void WebDisplayItemListImpl::appendEndFilterItem() {
 201   if (display_item_list_->RetainsIndividualDisplayItems()) {
 202     display_item_list_->CreateAndAppendItem<cc::EndFilterDisplayItem>();
 203   } else {
 204     display_item_list_->RasterIntoCanvas(cc::EndFilterDisplayItem());
 205   }
 206 }
 207
 208 void WebDisplayItemListImpl::appendScrollItem(
 209     const blink::WebSize& scrollOffset,
 210     ScrollContainerId) {
 211   SkMatrix44 matrix;
 212   matrix.setTranslate(-scrollOffset.width, -scrollOffset.height, 0);
 213   appendTransformItem(matrix);
 214 }
 215
 216 void WebDisplayItemListImpl::appendEndScrollItem() {
 217   appendEndTransformItem();
 218 }
 219
 220 WebDisplayItemListImpl::~WebDisplayItemListImpl() {
 221 }
 222
 223 }  // namespace cc_blink