1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// 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 "base/debug/trace_event.h"
#include "cc/content_layer_client.h"
#include "cc/picture.h"
#include "cc/rendering_stats.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkData.h"
#include "third_party/skia/include/core/SkTileGridPicture.h"
#include "third_party/skia/include/utils/SkPictureUtils.h"
#include "ui/gfx/rect_conversions.h"
#include "ui/gfx/skia_util.h"
namespace {
// URI label for a lazily decoded SkPixelRef.
const char labelLazyDecoded[] = "lazy";
// Tile size in recording coordinates used by SkTileGridPicture
const int tileGridSize = 256;
}
namespace cc {
scoped_refptr<Picture> Picture::Create(gfx::Rect layer_rect) {
return make_scoped_refptr(new Picture(layer_rect));
}
Picture::Picture(gfx::Rect layer_rect)
: layer_rect_(layer_rect) {
}
Picture::Picture(const skia::RefPtr<SkPicture>& picture,
gfx::Rect layer_rect,
gfx::Rect opaque_rect) :
layer_rect_(layer_rect),
opaque_rect_(opaque_rect),
picture_(picture) {
}
Picture::~Picture() {
}
scoped_refptr<Picture> Picture::Clone() const {
// SkPicture is not thread-safe to rasterize with, so return a thread-safe
// clone of it.
DCHECK(picture_);
skia::RefPtr<SkPicture> clone = skia::AdoptRef(picture_->clone());
return make_scoped_refptr(new Picture(clone, layer_rect_, opaque_rect_));
}
void Picture::Record(ContentLayerClient* painter,
RenderingStats* stats) {
TRACE_EVENT2("cc", "Picture::Record",
"width", layer_rect_.width(), "height", layer_rect_.height());
// Record() should only be called once.
DCHECK(!picture_);
picture_ = skia::AdoptRef(new SkTileGridPicture(
tileGridSize, tileGridSize, layer_rect_.width(), layer_rect_.height()));
SkCanvas* canvas = picture_->beginRecording(
layer_rect_.width(),
layer_rect_.height(),
SkPicture::kUsePathBoundsForClip_RecordingFlag |
SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
canvas->save();
canvas->translate(SkFloatToScalar(-layer_rect_.x()),
SkFloatToScalar(-layer_rect_.y()));
SkPaint paint;
paint.setAntiAlias(false);
paint.setXfermodeMode(SkXfermode::kClear_Mode);
SkRect layer_skrect = SkRect::MakeXYWH(layer_rect_.x(),
layer_rect_.y(),
layer_rect_.width(),
layer_rect_.height());
canvas->clipRect(layer_skrect);
canvas->drawRect(layer_skrect, paint);
gfx::RectF opaque_layer_rect;
base::TimeTicks begin_paint_time;
if (stats)
begin_paint_time = base::TimeTicks::Now();
painter->paintContents(canvas, layer_rect_, opaque_layer_rect);
if (stats) {
stats->totalPaintTime += base::TimeTicks::Now() - begin_paint_time;
stats->totalPixelsPainted +=
layer_rect_.width() * layer_rect_.height();
}
canvas->restore();
picture_->endRecording();
opaque_rect_ = gfx::ToEnclosedRect(opaque_layer_rect);
}
void Picture::Raster(
SkCanvas* canvas,
gfx::Rect content_rect,
float contents_scale) {
TRACE_EVENT2("cc", "Picture::Raster",
"width", layer_rect_.width(), "height", layer_rect_.height());
DCHECK(picture_);
canvas->save();
canvas->clipRect(gfx::RectToSkRect(content_rect));
canvas->scale(contents_scale, contents_scale);
canvas->translate(layer_rect_.x(), layer_rect_.y());
canvas->drawPicture(*picture_);
canvas->restore();
}
bool Picture::IsCheapInRect(const gfx::Rect& layer_rect) {
return false;
}
void Picture::GatherPixelRefs(const gfx::Rect& layer_rect,
std::list<skia::LazyPixelRef*>& pixel_ref_list) {
DCHECK(picture_);
SkData* pixel_refs = SkPictureUtils::GatherPixelRefs(
picture_.get(), SkRect::MakeXYWH(layer_rect.x(),
layer_rect.y(),
layer_rect.width(),
layer_rect.height()));
if (!pixel_refs)
return;
void* data = const_cast<void*>(pixel_refs->data());
if (!data) {
pixel_refs->unref();
return;
}
SkPixelRef** refs = reinterpret_cast<SkPixelRef**>(data);
for (unsigned int i = 0; i < pixel_refs->size() / sizeof(SkPixelRef*); ++i) {
if (*refs && (*refs)->getURI() && !strncmp(
(*refs)->getURI(), labelLazyDecoded, 4)) {
pixel_ref_list.push_back(static_cast<skia::LazyPixelRef*>(*refs));
}
refs++;
}
pixel_refs->unref();
}
} // namespace cc
|
