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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/graphics/unaccelerated_static_bitmap_image.h"
#include "base/process/memory.h"
#include "components/viz/common/gpu/context_provider.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/public/platform/web_graphics_context_3d_provider.h"
#include "third_party/blink/renderer/platform/graphics/accelerated_static_bitmap_image.h"
#include "third_party/blink/renderer/platform/graphics/canvas_resource_provider.h"
#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
#include "third_party/blink/renderer/platform/graphics/web_graphics_context_3d_provider_wrapper.h"
#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
#include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_copier_skia.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
#include "third_party/skia/include/core/SkImage.h"
#include "ui/gfx/skia_span_util.h"
namespace blink {
scoped_refptr<UnacceleratedStaticBitmapImage>
UnacceleratedStaticBitmapImage::Create(sk_sp<SkImage> image,
ImageOrientation orientation) {
if (!image)
return nullptr;
DCHECK(!image->isTextureBacked());
return base::AdoptRef(
new UnacceleratedStaticBitmapImage(std::move(image), orientation));
}
UnacceleratedStaticBitmapImage::UnacceleratedStaticBitmapImage(
sk_sp<SkImage> image,
ImageOrientation orientation)
: StaticBitmapImage(orientation) {
CHECK(image);
DCHECK(!image->isLazyGenerated());
paint_image_ =
CreatePaintImageBuilder()
.set_image(std::move(image), cc::PaintImage::GetNextContentId())
.TakePaintImage();
}
scoped_refptr<UnacceleratedStaticBitmapImage>
UnacceleratedStaticBitmapImage::Create(PaintImage image,
ImageOrientation orientation) {
return base::AdoptRef(
new UnacceleratedStaticBitmapImage(std::move(image), orientation));
}
UnacceleratedStaticBitmapImage::UnacceleratedStaticBitmapImage(
PaintImage image,
ImageOrientation orientation)
: StaticBitmapImage(orientation), paint_image_(std::move(image)) {
DCHECK(paint_image_);
}
UnacceleratedStaticBitmapImage::~UnacceleratedStaticBitmapImage() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (!original_skia_image_)
return;
if (!original_skia_image_task_runner_->BelongsToCurrentThread()) {
PostCrossThreadTask(
*original_skia_image_task_runner_, FROM_HERE,
CrossThreadBindOnce([](sk_sp<SkImage> image) { image.reset(); },
std::move(original_skia_image_)));
} else {
original_skia_image_.reset();
}
}
bool UnacceleratedStaticBitmapImage::IsOpaque() {
return paint_image_.IsOpaque();
}
void UnacceleratedStaticBitmapImage::Draw(
cc::PaintCanvas* canvas,
const cc::PaintFlags& flags,
const gfx::RectF& dst_rect,
const gfx::RectF& src_rect,
const ImageDrawOptions& draw_options) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
auto image = PaintImageForCurrentFrame();
if (image.may_be_lcp_candidate() != draw_options.may_be_lcp_candidate) {
image = PaintImageBuilder::WithCopy(std::move(image))
.set_may_be_lcp_candidate(draw_options.may_be_lcp_candidate)
.TakePaintImage();
}
StaticBitmapImage::DrawHelper(canvas, flags, dst_rect, src_rect, draw_options,
image);
}
PaintImage UnacceleratedStaticBitmapImage::PaintImageForCurrentFrame() {
return paint_image_;
}
void UnacceleratedStaticBitmapImage::Transfer() {
DETACH_FROM_THREAD(thread_checker_);
original_skia_image_ = paint_image_.GetSwSkImage();
original_skia_image_task_runner_ =
ThreadScheduler::Current()->CleanupTaskRunner();
}
bool UnacceleratedStaticBitmapImage::CopyToResourceProvider(
CanvasResourceProvider* resource_provider,
const gfx::Rect& copy_rect) {
DCHECK(resource_provider);
// Extract content to SkPixmap. Pixels are CPU backed resource and this
// should be freed.
sk_sp<SkImage> image = paint_image_.GetSwSkImage();
if (!image)
return false;
SkPixmap pixmap;
if (!image->peekPixels(&pixmap))
return false;
base::span<const uint8_t> pixels = gfx::SkPixmapToSpan(pixmap);
const size_t source_row_bytes = pixmap.rowBytes();
const size_t source_height = pixmap.height();
SkImageInfo copy_rect_info = paint_image_.GetSkImageInfo().makeWH(
copy_rect.width(), copy_rect.height());
const size_t dest_row_bytes =
copy_rect_info.bytesPerPixel() * static_cast<size_t>(copy_rect.width());
const size_t dest_height = static_cast<size_t>(copy_rect.height());
std::vector<uint8_t> dest_pixels;
if (source_row_bytes != dest_row_bytes || source_height != dest_height) {
dest_pixels.resize(dest_row_bytes * dest_height);
const size_t x_offset_bytes =
copy_rect_info.bytesPerPixel() * static_cast<size_t>(copy_rect.x());
size_t src_offset = copy_rect.y() * source_row_bytes + x_offset_bytes;
base::span<uint8_t> dest_data(dest_pixels);
for (size_t dst_y = 0; dst_y < dest_height;
++dst_y, src_offset += source_row_bytes) {
auto [dest_line, rest] = dest_data.split_at(dest_row_bytes);
dest_line.copy_from(pixels.subspan(src_offset, dest_row_bytes));
dest_data = rest;
}
pixels = dest_pixels;
}
return resource_provider->WritePixels(copy_rect_info, pixels.data(),
dest_row_bytes,
/*x=*/0, /*y=*/0);
}
SkImageInfo UnacceleratedStaticBitmapImage::GetSkImageInfo() const {
return paint_image_.GetSkImageInfo().makeWH(paint_image_.width(),
paint_image_.height());
}
} // namespace blink
|
