| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2012 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/picture.h" | |
| 6 | |
| 7 #include <set> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/base64.h" | |
| 11 #include "base/trace_event/trace_event.h" | |
| 12 #include "base/trace_event/trace_event_argument.h" | |
| 13 #include "base/values.h" | |
| 14 #include "cc/base/math_util.h" | |
| 15 #include "cc/base/util.h" | |
| 16 #include "cc/debug/picture_debug_util.h" | |
| 17 #include "cc/debug/traced_picture.h" | |
| 18 #include "cc/debug/traced_value.h" | |
| 19 #include "cc/layers/content_layer_client.h" | |
| 20 #include "skia/ext/pixel_ref_utils.h" | |
| 21 #include "third_party/skia/include/core/SkCanvas.h" | |
| 22 #include "third_party/skia/include/core/SkDrawPictureCallback.h" | |
| 23 #include "third_party/skia/include/core/SkPaint.h" | |
| 24 #include "third_party/skia/include/core/SkPictureRecorder.h" | |
| 25 #include "third_party/skia/include/core/SkStream.h" | |
| 26 #include "third_party/skia/include/utils/SkNullCanvas.h" | |
| 27 #include "third_party/skia/include/utils/SkPictureUtils.h" | |
| 28 #include "ui/gfx/codec/jpeg_codec.h" | |
| 29 #include "ui/gfx/codec/png_codec.h" | |
| 30 #include "ui/gfx/geometry/rect_conversions.h" | |
| 31 #include "ui/gfx/skia_util.h" | |
| 32 | |
| 33 namespace cc { | |
| 34 | |
| 35 namespace { | |
| 36 | |
| 37 bool DecodeBitmap(const void* buffer, size_t size, SkBitmap* bm) { | |
| 38 const unsigned char* data = static_cast<const unsigned char *>(buffer); | |
| 39 | |
| 40 // Try PNG first. | |
| 41 if (gfx::PNGCodec::Decode(data, size, bm)) | |
| 42 return true; | |
| 43 | |
| 44 // Try JPEG. | |
| 45 scoped_ptr<SkBitmap> decoded_jpeg(gfx::JPEGCodec::Decode(data, size)); | |
| 46 if (decoded_jpeg) { | |
| 47 *bm = *decoded_jpeg; | |
| 48 return true; | |
| 49 } | |
| 50 return false; | |
| 51 } | |
| 52 | |
| 53 } // namespace | |
| 54 | |
| 55 scoped_refptr<Picture> Picture::Create( | |
| 56 const gfx::Rect& layer_rect, | |
| 57 ContentLayerClient* client, | |
| 58 const gfx::Size& tile_grid_size, | |
| 59 bool gather_pixel_refs, | |
| 60 RecordingSource::RecordingMode recording_mode) { | |
| 61 scoped_refptr<Picture> picture = | |
| 62 make_scoped_refptr(new Picture(layer_rect, tile_grid_size)); | |
| 63 | |
| 64 picture->Record(client, recording_mode); | |
| 65 if (gather_pixel_refs) | |
| 66 picture->GatherPixelRefs(); | |
| 67 | |
| 68 return picture; | |
| 69 } | |
| 70 | |
| 71 Picture::Picture(const gfx::Rect& layer_rect, const gfx::Size& tile_grid_size) | |
| 72 : layer_rect_(layer_rect), pixel_refs_(tile_grid_size) { | |
| 73 // Instead of recording a trace event for object creation here, we wait for | |
| 74 // the picture to be recorded in Picture::Record. | |
| 75 } | |
| 76 | |
| 77 scoped_refptr<Picture> Picture::CreateFromSkpValue(const base::Value* value) { | |
| 78 // Decode the picture from base64. | |
| 79 std::string encoded; | |
| 80 if (!value->GetAsString(&encoded)) | |
| 81 return NULL; | |
| 82 | |
| 83 std::string decoded; | |
| 84 base::Base64Decode(encoded, &decoded); | |
| 85 SkMemoryStream stream(decoded.data(), decoded.size()); | |
| 86 | |
| 87 // Read the picture. This creates an empty picture on failure. | |
| 88 SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap); | |
| 89 if (skpicture == NULL) | |
| 90 return NULL; | |
| 91 | |
| 92 gfx::Rect layer_rect(gfx::SkIRectToRect(skpicture->cullRect().roundOut())); | |
| 93 return make_scoped_refptr(new Picture(skpicture, layer_rect)); | |
| 94 } | |
| 95 | |
| 96 scoped_refptr<Picture> Picture::CreateFromValue(const base::Value* raw_value) { | |
| 97 const base::DictionaryValue* value = NULL; | |
| 98 if (!raw_value->GetAsDictionary(&value)) | |
| 99 return NULL; | |
| 100 | |
| 101 // Decode the picture from base64. | |
| 102 std::string encoded; | |
| 103 if (!value->GetString("skp64", &encoded)) | |
| 104 return NULL; | |
| 105 | |
| 106 std::string decoded; | |
| 107 base::Base64Decode(encoded, &decoded); | |
| 108 SkMemoryStream stream(decoded.data(), decoded.size()); | |
| 109 | |
| 110 const base::Value* layer_rect_value = NULL; | |
| 111 if (!value->Get("params.layer_rect", &layer_rect_value)) | |
| 112 return NULL; | |
| 113 | |
| 114 gfx::Rect layer_rect; | |
| 115 if (!MathUtil::FromValue(layer_rect_value, &layer_rect)) | |
| 116 return NULL; | |
| 117 | |
| 118 // Read the picture. This creates an empty picture on failure. | |
| 119 SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap); | |
| 120 if (skpicture == NULL) | |
| 121 return NULL; | |
| 122 | |
| 123 return make_scoped_refptr(new Picture(skpicture, layer_rect)); | |
| 124 } | |
| 125 | |
| 126 Picture::Picture(SkPicture* picture, const gfx::Rect& layer_rect) | |
| 127 : layer_rect_(layer_rect), | |
| 128 picture_(skia::AdoptRef(picture)), | |
| 129 pixel_refs_(layer_rect.size()) { | |
| 130 } | |
| 131 | |
| 132 Picture::Picture(const skia::RefPtr<SkPicture>& picture, | |
| 133 const gfx::Rect& layer_rect, | |
| 134 const PixelRefMap& pixel_refs) | |
| 135 : layer_rect_(layer_rect), picture_(picture), pixel_refs_(pixel_refs) { | |
| 136 } | |
| 137 | |
| 138 Picture::~Picture() { | |
| 139 TRACE_EVENT_OBJECT_DELETED_WITH_ID( | |
| 140 TRACE_DISABLED_BY_DEFAULT("cc.debug.picture"), "cc::Picture", this); | |
| 141 } | |
| 142 | |
| 143 bool Picture::IsSuitableForGpuRasterization(const char** reason) const { | |
| 144 DCHECK(picture_); | |
| 145 | |
| 146 // TODO(hendrikw): SkPicture::suitableForGpuRasterization takes a GrContext. | |
| 147 // Currently the GrContext isn't used, and should probably be removed from | |
| 148 // skia. | |
| 149 return picture_->suitableForGpuRasterization(nullptr, reason); | |
| 150 } | |
| 151 | |
| 152 int Picture::ApproximateOpCount() const { | |
| 153 DCHECK(picture_); | |
| 154 return picture_->approximateOpCount(); | |
| 155 } | |
| 156 | |
| 157 size_t Picture::ApproximateMemoryUsage() const { | |
| 158 DCHECK(picture_); | |
| 159 return SkPictureUtils::ApproximateBytesUsed(picture_.get()); | |
| 160 } | |
| 161 | |
| 162 bool Picture::HasText() const { | |
| 163 DCHECK(picture_); | |
| 164 return picture_->hasText(); | |
| 165 } | |
| 166 | |
| 167 void Picture::Record(ContentLayerClient* painter, | |
| 168 RecordingSource::RecordingMode recording_mode) { | |
| 169 TRACE_EVENT2("cc", | |
| 170 "Picture::Record", | |
| 171 "data", | |
| 172 AsTraceableRecordData(), | |
| 173 "recording_mode", | |
| 174 recording_mode); | |
| 175 | |
| 176 DCHECK(!picture_); | |
| 177 | |
| 178 SkRTreeFactory factory; | |
| 179 SkPictureRecorder recorder; | |
| 180 | |
| 181 skia::RefPtr<SkCanvas> canvas; | |
| 182 canvas = skia::SharePtr(recorder.beginRecording( | |
| 183 layer_rect_.width(), layer_rect_.height(), &factory, | |
| 184 SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag)); | |
| 185 | |
| 186 ContentLayerClient::PaintingControlSetting painting_control = | |
| 187 ContentLayerClient::PAINTING_BEHAVIOR_NORMAL; | |
| 188 | |
| 189 switch (recording_mode) { | |
| 190 case RecordingSource::RECORD_NORMALLY: | |
| 191 // Already setup for normal recording. | |
| 192 break; | |
| 193 case RecordingSource::RECORD_WITH_SK_NULL_CANVAS: | |
| 194 canvas = skia::AdoptRef(SkCreateNullCanvas()); | |
| 195 break; | |
| 196 case RecordingSource::RECORD_WITH_PAINTING_DISABLED: | |
| 197 // We pass a disable flag through the paint calls when perfromance | |
| 198 // testing (the only time this case should ever arise) when we want to | |
| 199 // prevent the Blink GraphicsContext object from consuming any compute | |
| 200 // time. | |
| 201 canvas = skia::AdoptRef(SkCreateNullCanvas()); | |
| 202 painting_control = ContentLayerClient::DISPLAY_LIST_PAINTING_DISABLED; | |
| 203 break; | |
| 204 case RecordingSource::RECORD_WITH_CACHING_DISABLED: | |
| 205 // This mode should give the same results as RECORD_NORMALLY. | |
| 206 painting_control = ContentLayerClient::DISPLAY_LIST_CACHING_DISABLED; | |
| 207 break; | |
| 208 default: | |
| 209 // case RecordingSource::RECORD_WITH_CONSTRUCTION_DISABLED should | |
| 210 // not be reached | |
| 211 NOTREACHED(); | |
| 212 } | |
| 213 | |
| 214 canvas->save(); | |
| 215 canvas->translate(SkFloatToScalar(-layer_rect_.x()), | |
| 216 SkFloatToScalar(-layer_rect_.y())); | |
| 217 | |
| 218 canvas->clipRect(gfx::RectToSkRect(layer_rect_)); | |
| 219 | |
| 220 painter->PaintContents(canvas.get(), layer_rect_, painting_control); | |
| 221 | |
| 222 canvas->restore(); | |
| 223 picture_ = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 224 DCHECK(picture_); | |
| 225 | |
| 226 EmitTraceSnapshot(); | |
| 227 } | |
| 228 | |
| 229 void Picture::GatherPixelRefs() { | |
| 230 TRACE_EVENT2("cc", "Picture::GatherPixelRefs", | |
| 231 "width", layer_rect_.width(), | |
| 232 "height", layer_rect_.height()); | |
| 233 | |
| 234 DCHECK(picture_); | |
| 235 DCHECK(pixel_refs_.empty()); | |
| 236 if (!WillPlayBackBitmaps()) | |
| 237 return; | |
| 238 | |
| 239 pixel_refs_.GatherPixelRefsFromPicture(picture_.get()); | |
| 240 } | |
| 241 | |
| 242 int Picture::Raster(SkCanvas* canvas, | |
| 243 SkPicture::AbortCallback* callback, | |
| 244 const Region& negated_content_region, | |
| 245 float contents_scale) const { | |
| 246 TRACE_EVENT_BEGIN1( | |
| 247 "cc", | |
| 248 "Picture::Raster", | |
| 249 "data", | |
| 250 AsTraceableRasterData(contents_scale)); | |
| 251 | |
| 252 DCHECK(picture_); | |
| 253 | |
| 254 canvas->save(); | |
| 255 | |
| 256 for (Region::Iterator it(negated_content_region); it.has_rect(); it.next()) | |
| 257 canvas->clipRect(gfx::RectToSkRect(it.rect()), SkRegion::kDifference_Op); | |
| 258 | |
| 259 canvas->scale(contents_scale, contents_scale); | |
| 260 canvas->translate(layer_rect_.x(), layer_rect_.y()); | |
| 261 if (callback) { | |
| 262 // If we have a callback, we need to call |draw()|, |drawPicture()| doesn't | |
| 263 // take a callback. This is used by |AnalysisCanvas| to early out. | |
| 264 picture_->playback(canvas, callback); | |
| 265 } else { | |
| 266 // Prefer to call |drawPicture()| on the canvas since it could place the | |
| 267 // entire picture on the canvas instead of parsing the skia operations. | |
| 268 canvas->drawPicture(picture_.get()); | |
| 269 } | |
| 270 SkIRect bounds; | |
| 271 canvas->getClipDeviceBounds(&bounds); | |
| 272 canvas->restore(); | |
| 273 TRACE_EVENT_END1( | |
| 274 "cc", "Picture::Raster", | |
| 275 "num_pixels_rasterized", bounds.width() * bounds.height()); | |
| 276 return bounds.width() * bounds.height(); | |
| 277 } | |
| 278 | |
| 279 void Picture::Replay(SkCanvas* canvas, SkPicture::AbortCallback* callback) { | |
| 280 TRACE_EVENT_BEGIN0("cc", "Picture::Replay"); | |
| 281 DCHECK(picture_); | |
| 282 picture_->playback(canvas, callback); | |
| 283 SkIRect bounds; | |
| 284 canvas->getClipDeviceBounds(&bounds); | |
| 285 TRACE_EVENT_END1("cc", "Picture::Replay", | |
| 286 "num_pixels_replayed", bounds.width() * bounds.height()); | |
| 287 } | |
| 288 | |
| 289 scoped_ptr<base::Value> Picture::AsValue() const { | |
| 290 // Encode the picture as base64. | |
| 291 scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue()); | |
| 292 res->Set("params.layer_rect", MathUtil::AsValue(layer_rect_).release()); | |
| 293 std::string b64_picture; | |
| 294 PictureDebugUtil::SerializeAsBase64(picture_.get(), &b64_picture); | |
| 295 res->SetString("skp64", b64_picture); | |
| 296 return res.Pass(); | |
| 297 } | |
| 298 | |
| 299 void Picture::EmitTraceSnapshot() const { | |
| 300 TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID( | |
| 301 TRACE_DISABLED_BY_DEFAULT("cc.debug.picture") "," | |
| 302 TRACE_DISABLED_BY_DEFAULT("devtools.timeline.picture"), | |
| 303 "cc::Picture", | |
| 304 this, | |
| 305 TracedPicture::AsTraceablePicture(this)); | |
| 306 } | |
| 307 | |
| 308 void Picture::EmitTraceSnapshotAlias(Picture* original) const { | |
| 309 TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID( | |
| 310 TRACE_DISABLED_BY_DEFAULT("cc.debug.picture") "," | |
| 311 TRACE_DISABLED_BY_DEFAULT("devtools.timeline.picture"), | |
| 312 "cc::Picture", | |
| 313 this, | |
| 314 TracedPicture::AsTraceablePictureAlias(original)); | |
| 315 } | |
| 316 | |
| 317 PixelRefMap::Iterator Picture::GetPixelRefMapIterator( | |
| 318 const gfx::Rect& layer_rect) const { | |
| 319 return PixelRefMap::Iterator(layer_rect, this); | |
| 320 } | |
| 321 | |
| 322 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | |
| 323 Picture::AsTraceableRasterData(float scale) const { | |
| 324 scoped_refptr<base::trace_event::TracedValue> raster_data = | |
| 325 new base::trace_event::TracedValue(); | |
| 326 TracedValue::SetIDRef(this, raster_data.get(), "picture_id"); | |
| 327 raster_data->SetDouble("scale", scale); | |
| 328 return raster_data; | |
| 329 } | |
| 330 | |
| 331 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | |
| 332 Picture::AsTraceableRecordData() const { | |
| 333 scoped_refptr<base::trace_event::TracedValue> record_data = | |
| 334 new base::trace_event::TracedValue(); | |
| 335 TracedValue::SetIDRef(this, record_data.get(), "picture_id"); | |
| 336 MathUtil::AddToTracedValue("layer_rect", layer_rect_, record_data.get()); | |
| 337 return record_data; | |
| 338 } | |
| 339 | |
| 340 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1144693002:
cc: Move files out of cc/resources/. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master