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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright (c) 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 "content/browser/renderer_host/backing_store_aura.h"
#include "content/browser/renderer_host/dip_util.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/public/browser/render_widget_host.h"
#include "skia/ext/platform_canvas.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/rect_conversions.h"
#include "ui/gfx/size_conversions.h"
#include "ui/gfx/vector2d_conversions.h"
namespace {
gfx::Size ToPixelSize(gfx::Size dipSize, float scale) {
return gfx::ToCeiledSize(gfx::ScaleSize(dipSize, scale));
}
} // namespace
namespace content {
// Assume that somewhere along the line, someone will do width * height * 4
// with signed numbers. If the maximum value is 2**31, then 2**31 / 4 =
// 2**29 and floor(sqrt(2**29)) = 23170.
// Max height and width for layers
static const int kMaxVideoLayerSize = 23170;
BackingStoreAura::BackingStoreAura(RenderWidgetHost* widget,
const gfx::Size& size)
: BackingStore(widget, size) {
device_scale_factor_ =
ui::GetScaleFactorScale(GetScaleFactorForView(widget->GetView()));
gfx::Size pixel_size = ToPixelSize(size, device_scale_factor_);
bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
pixel_size.width(), pixel_size.height());
bitmap_.allocPixels();
canvas_.reset(new SkCanvas(bitmap_));
}
BackingStoreAura::~BackingStoreAura() {
}
void BackingStoreAura::SkiaShowRect(const gfx::Point& point,
gfx::Canvas* canvas) {
gfx::ImageSkia image = gfx::ImageSkia(gfx::ImageSkiaRep(bitmap_,
ui::GetScaleFactorFromScale(device_scale_factor_)));
canvas->DrawImageInt(image, point.x(), point.y());
}
void BackingStoreAura::ScaleFactorChanged(float device_scale_factor) {
if (device_scale_factor == device_scale_factor_)
return;
gfx::Size old_pixel_size = ToPixelSize(size(), device_scale_factor_);
device_scale_factor_ = device_scale_factor;
gfx::Size pixel_size = ToPixelSize(size(), device_scale_factor_);
SkBitmap new_bitmap;
new_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
pixel_size.width(), pixel_size.height());
new_bitmap.allocPixels();
scoped_ptr<SkCanvas> new_canvas(new SkCanvas(new_bitmap));
// Copy old contents; a low-res flash is better than a black flash.
SkPaint copy_paint;
copy_paint.setXfermodeMode(SkXfermode::kSrc_Mode);
SkIRect src_rect = SkIRect::MakeWH(old_pixel_size.width(),
old_pixel_size.height());
SkRect dst_rect = SkRect::MakeWH(pixel_size.width(), pixel_size.height());
new_canvas.get()->drawBitmapRect(bitmap_, &src_rect, dst_rect, ©_paint);
canvas_.swap(new_canvas);
bitmap_ = new_bitmap;
}
size_t BackingStoreAura::MemorySize() {
// NOTE: The computation may be different when the canvas is a subrectangle of
// a larger bitmap.
return ToPixelSize(size(), device_scale_factor_).GetArea() * 4;
}
void BackingStoreAura::PaintToBackingStore(
RenderProcessHost* process,
TransportDIB::Id bitmap,
const gfx::Rect& bitmap_rect,
const std::vector<gfx::Rect>& copy_rects,
float scale_factor,
const base::Closure& completion_callback,
bool* scheduled_completion_callback) {
*scheduled_completion_callback = false;
if (bitmap_rect.IsEmpty())
return;
gfx::Rect pixel_bitmap_rect = gfx::ToEnclosingRect(
gfx::ScaleRect(bitmap_rect, scale_factor));
const int width = pixel_bitmap_rect.width();
const int height = pixel_bitmap_rect.height();
if (width <= 0 || width > kMaxVideoLayerSize ||
height <= 0 || height > kMaxVideoLayerSize)
return;
TransportDIB* dib = process->GetTransportDIB(bitmap);
if (!dib)
return;
SkPaint copy_paint;
copy_paint.setXfermodeMode(SkXfermode::kSrc_Mode);
SkBitmap sk_bitmap;
sk_bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
sk_bitmap.setPixels(dib->memory());
for (size_t i = 0; i < copy_rects.size(); i++) {
const gfx::Rect pixel_copy_rect = gfx::ToEnclosingRect(
gfx::ScaleRect(copy_rects[i], scale_factor));
int x = pixel_copy_rect.x() - pixel_bitmap_rect.x();
int y = pixel_copy_rect.y() - pixel_bitmap_rect.y();
SkIRect srcrect = SkIRect::MakeXYWH(x, y,
pixel_copy_rect.width(),
pixel_copy_rect.height());
const gfx::Rect pixel_copy_dst_rect = gfx::ToEnclosingRect(
gfx::ScaleRect(copy_rects[i], device_scale_factor_));
SkRect dstrect = SkRect::MakeXYWH(
SkIntToScalar(pixel_copy_dst_rect.x()),
SkIntToScalar(pixel_copy_dst_rect.y()),
SkIntToScalar(pixel_copy_dst_rect.width()),
SkIntToScalar(pixel_copy_dst_rect.height()));
canvas_.get()->drawBitmapRect(sk_bitmap, &srcrect, dstrect, ©_paint);
}
}
void BackingStoreAura::ScrollBackingStore(const gfx::Vector2d& delta,
const gfx::Rect& clip_rect,
const gfx::Size& view_size) {
gfx::Rect pixel_rect = gfx::ToEnclosingRect(
gfx::ScaleRect(clip_rect, device_scale_factor_));
gfx::Vector2d pixel_delta = gfx::ToFlooredVector2d(
gfx::ScaleVector2d(delta, device_scale_factor_));
int x = std::min(pixel_rect.x(), pixel_rect.x() - pixel_delta.x());
int y = std::min(pixel_rect.y(), pixel_rect.y() - pixel_delta.y());
int w = pixel_rect.width() + abs(pixel_delta.x());
int h = pixel_rect.height() + abs(pixel_delta.y());
SkIRect rect = SkIRect::MakeXYWH(x, y, w, h);
bitmap_.scrollRect(&rect, pixel_delta.x(), pixel_delta.y());
}
bool BackingStoreAura::CopyFromBackingStore(const gfx::Rect& rect,
skia::PlatformBitmap* output) {
const int width =
std::min(size().width(), rect.width()) * device_scale_factor_;
const int height =
std::min(size().height(), rect.height()) * device_scale_factor_;
if (!output->Allocate(width, height, true))
return false;
SkIRect skrect = SkIRect::MakeXYWH(rect.x(), rect.y(), width, height);
SkBitmap b;
if (!canvas_->readPixels(skrect, &b))
return false;
SkCanvas(output->GetBitmap()).writePixels(b, rect.x(), rect.y());
return true;
}
} // namespace content
|
