1 // Copyright (c) 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.
5 #include "content/renderer/pepper/pepper_graphics_2d_host.h"
8 #include "base/logging.h"
9 #include "base/message_loop/message_loop.h"
10 #include "base/trace_event/trace_event.h"
11 #include "cc/resources/shared_bitmap.h"
12 #include "cc/resources/texture_mailbox.h"
13 #include "content/child/child_shared_bitmap_manager.h"
14 #include "content/public/renderer/render_thread.h"
15 #include "content/public/renderer/renderer_ppapi_host.h"
16 #include "content/renderer/pepper/gfx_conversion.h"
17 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
18 #include "content/renderer/pepper/plugin_instance_throttler_impl.h"
19 #include "content/renderer/pepper/ppb_image_data_impl.h"
20 #include "content/renderer/render_thread_impl.h"
21 #include "ppapi/c/pp_bool.h"
22 #include "ppapi/c/pp_errors.h"
23 #include "ppapi/c/pp_rect.h"
24 #include "ppapi/c/pp_resource.h"
25 #include "ppapi/host/dispatch_host_message.h"
26 #include "ppapi/host/host_message_context.h"
27 #include "ppapi/host/ppapi_host.h"
28 #include "ppapi/proxy/ppapi_messages.h"
29 #include "ppapi/shared_impl/ppb_view_shared.h"
30 #include "ppapi/thunk/enter.h"
31 #include "skia/ext/platform_canvas.h"
32 #include "third_party/skia/include/core/SkBitmap.h"
33 #include "ui/gfx/blit.h"
34 #include "ui/gfx/geometry/point_conversions.h"
35 #include "ui/gfx/geometry/rect.h"
36 #include "ui/gfx/geometry/rect_conversions.h"
37 #include "ui/gfx/geometry/size_conversions.h"
38 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
39 #include "ui/gfx/skia_util.h"
41 #if defined(OS_MACOSX)
42 #include "base/mac/scoped_cftyperef.h"
45 using ppapi::thunk::EnterResourceNoLock
;
46 using ppapi::thunk::PPB_ImageData_API
;
52 const int64 kOffscreenCallbackDelayMs
= 1000 / 30; // 30 fps
54 // Converts a rect inside an image of the given dimensions. The rect may be
55 // NULL to indicate it should be the entire image. If the rect is outside of
56 // the image, this will do nothing and return false.
57 bool ValidateAndConvertRect(const PP_Rect
* rect
,
62 // Use the entire image area.
63 *dest
= gfx::Rect(0, 0, image_width
, image_height
);
65 // Validate the passed-in area.
66 if (rect
->point
.x
< 0 || rect
->point
.y
< 0 || rect
->size
.width
<= 0 ||
67 rect
->size
.height
<= 0)
70 // Check the max bounds, being careful of overflow.
71 if (static_cast<int64
>(rect
->point
.x
) +
72 static_cast<int64
>(rect
->size
.width
) >
73 static_cast<int64
>(image_width
))
75 if (static_cast<int64
>(rect
->point
.y
) +
76 static_cast<int64
>(rect
->size
.height
) >
77 static_cast<int64
>(image_height
))
81 rect
->point
.x
, rect
->point
.y
, rect
->size
.width
, rect
->size
.height
);
86 // Converts BGRA <-> RGBA.
87 void ConvertBetweenBGRAandRGBA(const uint32_t* input
,
90 for (int i
= 0; i
< pixel_length
; i
++) {
91 const unsigned char* pixel_in
=
92 reinterpret_cast<const unsigned char*>(&input
[i
]);
93 unsigned char* pixel_out
= reinterpret_cast<unsigned char*>(&output
[i
]);
94 pixel_out
[0] = pixel_in
[2];
95 pixel_out
[1] = pixel_in
[1];
96 pixel_out
[2] = pixel_in
[0];
97 pixel_out
[3] = pixel_in
[3];
101 // Converts ImageData from PP_IMAGEDATAFORMAT_BGRA_PREMUL to
102 // PP_IMAGEDATAFORMAT_RGBA_PREMUL, or reverse. It's assumed that the
103 // destination image is always mapped (so will have non-NULL data).
104 void ConvertImageData(PPB_ImageData_Impl
* src_image
,
105 const SkIRect
& src_rect
,
106 PPB_ImageData_Impl
* dest_image
,
107 const SkRect
& dest_rect
) {
108 ImageDataAutoMapper
auto_mapper(src_image
);
110 DCHECK(src_image
->format() != dest_image
->format());
111 DCHECK(PPB_ImageData_Impl::IsImageDataFormatSupported(src_image
->format()));
112 DCHECK(PPB_ImageData_Impl::IsImageDataFormatSupported(dest_image
->format()));
114 const SkBitmap
* src_bitmap
= src_image
->GetMappedBitmap();
115 const SkBitmap
* dest_bitmap
= dest_image
->GetMappedBitmap();
116 if (src_rect
.width() == src_image
->width() &&
117 dest_rect
.width() == dest_image
->width()) {
118 // Fast path if the full line needs to be converted.
119 ConvertBetweenBGRAandRGBA(
120 src_bitmap
->getAddr32(static_cast<int>(src_rect
.fLeft
),
121 static_cast<int>(src_rect
.fTop
)),
122 src_rect
.width() * src_rect
.height(),
123 dest_bitmap
->getAddr32(static_cast<int>(dest_rect
.fLeft
),
124 static_cast<int>(dest_rect
.fTop
)));
126 // Slow path where we convert line by line.
127 for (int y
= 0; y
< src_rect
.height(); y
++) {
128 ConvertBetweenBGRAandRGBA(
129 src_bitmap
->getAddr32(static_cast<int>(src_rect
.fLeft
),
130 static_cast<int>(src_rect
.fTop
+ y
)),
132 dest_bitmap
->getAddr32(static_cast<int>(dest_rect
.fLeft
),
133 static_cast<int>(dest_rect
.fTop
+ y
)));
140 struct PepperGraphics2DHost::QueuedOperation
{
141 enum Type
{ PAINT
, SCROLL
, REPLACE
, };
143 QueuedOperation(Type t
)
144 : type(t
), paint_x(0), paint_y(0), scroll_dx(0), scroll_dy(0) {}
148 // Valid when type == PAINT.
149 scoped_refptr
<PPB_ImageData_Impl
> paint_image
;
150 int paint_x
, paint_y
;
151 gfx::Rect paint_src_rect
;
153 // Valid when type == SCROLL.
154 gfx::Rect scroll_clip_rect
;
155 int scroll_dx
, scroll_dy
;
157 // Valid when type == REPLACE.
158 scoped_refptr
<PPB_ImageData_Impl
> replace_image
;
162 PepperGraphics2DHost
* PepperGraphics2DHost::Create(
163 RendererPpapiHost
* host
,
164 PP_Instance instance
,
165 PP_Resource resource
,
167 PP_Bool is_always_opaque
,
168 scoped_refptr
<PPB_ImageData_Impl
> backing_store
) {
169 PepperGraphics2DHost
* resource_host
=
170 new PepperGraphics2DHost(host
, instance
, resource
);
171 if (!resource_host
->Init(size
.width
,
173 PP_ToBool(is_always_opaque
),
175 delete resource_host
;
178 return resource_host
;
181 PepperGraphics2DHost::PepperGraphics2DHost(RendererPpapiHost
* host
,
182 PP_Instance instance
,
183 PP_Resource resource
)
184 : ResourceHost(host
->GetPpapiHost(), instance
, resource
),
185 renderer_ppapi_host_(host
),
186 bound_instance_(NULL
),
187 need_flush_ack_(false),
188 offscreen_flush_pending_(false),
189 is_always_opaque_(false),
191 is_running_in_process_(host
->IsRunningInProcess()),
192 texture_mailbox_modified_(true) {}
194 PepperGraphics2DHost::~PepperGraphics2DHost() {
195 // Unbind from the instance when destroyed if we're still bound.
197 bound_instance_
->BindGraphics(bound_instance_
->pp_instance(), 0);
200 bool PepperGraphics2DHost::Init(
203 bool is_always_opaque
,
204 scoped_refptr
<PPB_ImageData_Impl
> backing_store
) {
205 // The underlying PPB_ImageData_Impl will validate the dimensions.
206 image_data_
= backing_store
;
207 if (!image_data_
->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(),
211 !image_data_
->Map()) {
215 is_always_opaque_
= is_always_opaque
;
220 int32_t PepperGraphics2DHost::OnResourceMessageReceived(
221 const IPC::Message
& msg
,
222 ppapi::host::HostMessageContext
* context
) {
223 PPAPI_BEGIN_MESSAGE_MAP(PepperGraphics2DHost
, msg
)
224 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_PaintImageData
,
225 OnHostMsgPaintImageData
)
226 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_Scroll
,
228 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_ReplaceContents
,
229 OnHostMsgReplaceContents
)
230 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_Flush
,
232 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_SetScale
,
234 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_ReadImageData
,
235 OnHostMsgReadImageData
)
236 PPAPI_END_MESSAGE_MAP()
237 return PP_ERROR_FAILED
;
240 bool PepperGraphics2DHost::IsGraphics2DHost() { return true; }
242 bool PepperGraphics2DHost::ReadImageData(PP_Resource image
,
243 const PP_Point
* top_left
) {
244 // Get and validate the image object to paint into.
245 EnterResourceNoLock
<PPB_ImageData_API
> enter(image
, true);
248 PPB_ImageData_Impl
* image_resource
=
249 static_cast<PPB_ImageData_Impl
*>(enter
.object());
250 if (!PPB_ImageData_Impl::IsImageDataFormatSupported(image_resource
->format()))
251 return false; // Must be in the right format.
253 // Validate the bitmap position.
256 static_cast<int64
>(x
) + static_cast<int64
>(image_resource
->width()) >
257 image_data_
->width())
261 static_cast<int64
>(y
) + static_cast<int64
>(image_resource
->height()) >
262 image_data_
->height())
265 ImageDataAutoMapper
auto_mapper(image_resource
);
266 if (!auto_mapper
.is_valid())
269 SkIRect src_irect
= {x
, y
, x
+ image_resource
->width(),
270 y
+ image_resource
->height()};
271 SkRect dest_rect
= {SkIntToScalar(0), SkIntToScalar(0),
272 SkIntToScalar(image_resource
->width()),
273 SkIntToScalar(image_resource
->height())};
275 if (image_resource
->format() != image_data_
->format()) {
276 // Convert the image data if the format does not match.
277 ConvertImageData(image_data_
.get(), src_irect
, image_resource
, dest_rect
);
279 SkCanvas
* dest_canvas
= image_resource
->GetCanvas();
281 // We want to replace the contents of the bitmap rather than blend.
283 paint
.setXfermodeMode(SkXfermode::kSrc_Mode
);
284 dest_canvas
->drawBitmapRect(
285 *image_data_
->GetMappedBitmap(), &src_irect
, dest_rect
, &paint
);
290 bool PepperGraphics2DHost::BindToInstance(
291 PepperPluginInstanceImpl
* new_instance
) {
292 if (new_instance
&& new_instance
->pp_instance() != pp_instance())
293 return false; // Can't bind other instance's contexts.
294 if (bound_instance_
== new_instance
)
295 return true; // Rebinding the same device, nothing to do.
296 if (bound_instance_
&& new_instance
)
297 return false; // Can't change a bound device.
300 // When the device is detached, we'll not get any more paint callbacks so
301 // we need to clear the list, but we still want to issue any pending
302 // callbacks to the plugin.
304 ScheduleOffscreenFlushAck();
306 // Devices being replaced, redraw the plugin.
307 new_instance
->InvalidateRect(gfx::Rect());
310 cached_bitmap_
.reset();
311 texture_mailbox_modified_
= true;
313 bound_instance_
= new_instance
;
317 // The |backing_bitmap| must be clipped to the |plugin_rect| to avoid painting
318 // outside the plugin area. This can happen if the plugin has been resized since
319 // PaintImageData verified the image is within the plugin size.
320 void PepperGraphics2DHost::Paint(blink::WebCanvas
* canvas
,
321 const gfx::Rect
& plugin_rect
,
322 const gfx::Rect
& paint_rect
) {
323 TRACE_EVENT0("pepper", "PepperGraphics2DHost::Paint");
324 ImageDataAutoMapper
auto_mapper(image_data_
.get());
325 const SkBitmap
& backing_bitmap
= *image_data_
->GetMappedBitmap();
327 gfx::Rect invalidate_rect
= plugin_rect
;
328 invalidate_rect
.Intersect(paint_rect
);
329 SkRect sk_invalidate_rect
= gfx::RectToSkRect(invalidate_rect
);
330 SkAutoCanvasRestore
auto_restore(canvas
, true);
331 canvas
->clipRect(sk_invalidate_rect
);
332 gfx::Size
pixel_image_size(image_data_
->width(), image_data_
->height());
333 gfx::Size image_size
=
334 gfx::ToFlooredSize(gfx::ScaleSize(pixel_image_size
, scale_
));
336 PepperPluginInstance
* plugin_instance
=
337 renderer_ppapi_host_
->GetPluginInstance(pp_instance());
338 if (!plugin_instance
)
340 if (plugin_instance
->IsFullPagePlugin()) {
341 // When we're resizing a window with a full-frame plugin, the plugin may
342 // not yet have bound a new device, which will leave parts of the
343 // background exposed if the window is getting larger. We want this to
344 // show white (typically less jarring) rather than black or uninitialized.
345 // We don't do this for non-full-frame plugins since we specifically want
346 // the page background to show through.
347 SkAutoCanvasRestore
auto_restore(canvas
, true);
348 SkRect image_data_rect
=
349 gfx::RectToSkRect(gfx::Rect(plugin_rect
.origin(), image_size
));
350 canvas
->clipRect(image_data_rect
, SkRegion::kDifference_Op
);
353 paint
.setXfermodeMode(SkXfermode::kSrc_Mode
);
354 paint
.setColor(SK_ColorWHITE
);
355 canvas
->drawRect(sk_invalidate_rect
, paint
);
359 // Copy to device independent bitmap when target canvas doesn't support
361 if (!skia::SupportsPlatformPaint(canvas
))
362 backing_bitmap
.copyTo(&image
, kN32_SkColorType
);
364 image
= backing_bitmap
;
367 if (is_always_opaque_
) {
368 // When we know the device is opaque, we can disable blending for slightly
369 // more optimized painting.
370 paint
.setXfermodeMode(SkXfermode::kSrc_Mode
);
374 origin
.set(SkIntToScalar(plugin_rect
.x()), SkIntToScalar(plugin_rect
.y()));
376 SkPoint pixel_origin
= origin
;
378 if (scale_
!= 1.0f
&& scale_
> 0.0f
) {
379 canvas
->scale(scale_
, scale_
);
380 pixel_origin
.set(pixel_origin
.x() * (1.0f
/ scale_
),
381 pixel_origin
.y() * (1.0f
/ scale_
));
383 canvas
->drawBitmap(image
, pixel_origin
.x(), pixel_origin
.y(), &paint
);
386 void PepperGraphics2DHost::ViewInitiatedPaint() {
387 TRACE_EVENT0("pepper", "PepperGraphics2DHost::ViewInitiatedPaint");
388 if (need_flush_ack_
) {
390 need_flush_ack_
= false;
394 void PepperGraphics2DHost::SetScale(float scale
) { scale_
= scale
; }
396 float PepperGraphics2DHost::GetScale() const { return scale_
; }
398 bool PepperGraphics2DHost::IsAlwaysOpaque() const { return is_always_opaque_
; }
400 PPB_ImageData_Impl
* PepperGraphics2DHost::ImageData() {
401 return image_data_
.get();
404 gfx::Size
PepperGraphics2DHost::Size() const {
405 if (!image_data_
.get())
407 return gfx::Size(image_data_
->width(), image_data_
->height());
410 void PepperGraphics2DHost::ClearCache() {
411 cached_bitmap_
.reset();
414 int32_t PepperGraphics2DHost::OnHostMsgPaintImageData(
415 ppapi::host::HostMessageContext
* context
,
416 const ppapi::HostResource
& image_data
,
417 const PP_Point
& top_left
,
418 bool src_rect_specified
,
419 const PP_Rect
& src_rect
) {
420 EnterResourceNoLock
<PPB_ImageData_API
> enter(image_data
.host_resource(),
423 return PP_ERROR_BADRESOURCE
;
424 PPB_ImageData_Impl
* image_resource
=
425 static_cast<PPB_ImageData_Impl
*>(enter
.object());
427 QueuedOperation
operation(QueuedOperation::PAINT
);
428 operation
.paint_image
= image_resource
;
429 if (!ValidateAndConvertRect(src_rect_specified
? &src_rect
: NULL
,
430 image_resource
->width(),
431 image_resource
->height(),
432 &operation
.paint_src_rect
))
433 return PP_ERROR_BADARGUMENT
;
435 // Validate the bitmap position using the previously-validated rect, there
436 // should be no painted area outside of the image.
437 int64 x64
= static_cast<int64
>(top_left
.x
);
438 int64 y64
= static_cast<int64
>(top_left
.y
);
439 if (x64
+ static_cast<int64
>(operation
.paint_src_rect
.x()) < 0 ||
440 x64
+ static_cast<int64
>(operation
.paint_src_rect
.right()) >
441 image_data_
->width())
442 return PP_ERROR_BADARGUMENT
;
443 if (y64
+ static_cast<int64
>(operation
.paint_src_rect
.y()) < 0 ||
444 y64
+ static_cast<int64
>(operation
.paint_src_rect
.bottom()) >
445 image_data_
->height())
446 return PP_ERROR_BADARGUMENT
;
447 operation
.paint_x
= top_left
.x
;
448 operation
.paint_y
= top_left
.y
;
450 queued_operations_
.push_back(operation
);
454 int32_t PepperGraphics2DHost::OnHostMsgScroll(
455 ppapi::host::HostMessageContext
* context
,
458 const PP_Point
& amount
) {
459 QueuedOperation
operation(QueuedOperation::SCROLL
);
460 if (!ValidateAndConvertRect(clip_specified
? &clip
: NULL
,
461 image_data_
->width(),
462 image_data_
->height(),
463 &operation
.scroll_clip_rect
))
464 return PP_ERROR_BADARGUMENT
;
466 // If we're being asked to scroll by more than the clip rect size, just
467 // ignore this scroll command and say it worked.
470 if (dx
<= -image_data_
->width() || dx
>= image_data_
->width() ||
471 dy
<= -image_data_
->height() || dy
>= image_data_
->height())
472 return PP_ERROR_BADARGUMENT
;
474 operation
.scroll_dx
= dx
;
475 operation
.scroll_dy
= dy
;
477 queued_operations_
.push_back(operation
);
481 int32_t PepperGraphics2DHost::OnHostMsgReplaceContents(
482 ppapi::host::HostMessageContext
* context
,
483 const ppapi::HostResource
& image_data
) {
484 EnterResourceNoLock
<PPB_ImageData_API
> enter(image_data
.host_resource(),
487 return PP_ERROR_BADRESOURCE
;
488 PPB_ImageData_Impl
* image_resource
=
489 static_cast<PPB_ImageData_Impl
*>(enter
.object());
491 if (!PPB_ImageData_Impl::IsImageDataFormatSupported(image_resource
->format()))
492 return PP_ERROR_BADARGUMENT
;
494 if (image_resource
->width() != image_data_
->width() ||
495 image_resource
->height() != image_data_
->height())
496 return PP_ERROR_BADARGUMENT
;
498 QueuedOperation
operation(QueuedOperation::REPLACE
);
499 operation
.replace_image
= image_resource
;
500 queued_operations_
.push_back(operation
);
504 int32_t PepperGraphics2DHost::OnHostMsgFlush(
505 ppapi::host::HostMessageContext
* context
,
506 const std::vector
<ui::LatencyInfo
>& latency_info
) {
507 // Don't allow more than one pending flush at a time.
508 if (HasPendingFlush())
509 return PP_ERROR_INPROGRESS
;
512 bound_instance_
->AddLatencyInfo(latency_info
);
514 PP_Resource old_image_data
= 0;
515 flush_reply_context_
= context
->MakeReplyMessageContext();
516 if (is_running_in_process_
)
519 // Reuse image data when running out of process.
520 int32_t result
= Flush(&old_image_data
);
522 if (old_image_data
) {
523 // If the Graphics2D has an old image data it's not using any more, send
524 // it back to the plugin for possible re-use. See ppb_image_data_proxy.cc
525 // for a description how this process works.
526 ppapi::HostResource old_image_data_host_resource
;
527 old_image_data_host_resource
.SetHostResource(pp_instance(), old_image_data
);
528 host()->Send(new PpapiMsg_PPBImageData_NotifyUnusedImageData(
529 ppapi::API_ID_PPB_IMAGE_DATA
, old_image_data_host_resource
));
535 int32_t PepperGraphics2DHost::OnHostMsgSetScale(
536 ppapi::host::HostMessageContext
* context
,
542 return PP_ERROR_BADARGUMENT
;
545 int32_t PepperGraphics2DHost::OnHostMsgReadImageData(
546 ppapi::host::HostMessageContext
* context
,
548 const PP_Point
& top_left
) {
549 context
->reply_msg
= PpapiPluginMsg_Graphics2D_ReadImageDataAck();
550 return ReadImageData(image
, &top_left
) ? PP_OK
: PP_ERROR_FAILED
;
553 void PepperGraphics2DHost::ReleaseCallback(scoped_ptr
<cc::SharedBitmap
> bitmap
,
554 const gfx::Size
& bitmap_size
,
556 bool lost_resource
) {
557 cached_bitmap_
.reset();
558 // Only keep around a cached bitmap if the plugin is currently drawing (has
559 // need_flush_ack_ set).
560 if (need_flush_ack_
&& bound_instance_
)
561 cached_bitmap_
= bitmap
.Pass();
562 cached_bitmap_size_
= bitmap_size
;
565 bool PepperGraphics2DHost::PrepareTextureMailbox(
566 cc::TextureMailbox
* mailbox
,
567 scoped_ptr
<cc::SingleReleaseCallback
>* release_callback
) {
568 if (!texture_mailbox_modified_
)
570 // TODO(jbauman): Send image_data_ through mailbox to avoid copy.
571 gfx::Size
pixel_image_size(image_data_
->width(), image_data_
->height());
572 scoped_ptr
<cc::SharedBitmap
> shared_bitmap
;
573 if (cached_bitmap_
) {
574 if (cached_bitmap_size_
== pixel_image_size
)
575 shared_bitmap
= cached_bitmap_
.Pass();
577 cached_bitmap_
.reset();
579 if (!shared_bitmap
) {
580 shared_bitmap
= RenderThreadImpl::current()
581 ->shared_bitmap_manager()
582 ->AllocateSharedBitmap(pixel_image_size
);
586 void* src
= image_data_
->Map();
587 memcpy(shared_bitmap
->pixels(),
589 cc::SharedBitmap::CheckedSizeInBytes(pixel_image_size
));
590 image_data_
->Unmap();
592 *mailbox
= cc::TextureMailbox(shared_bitmap
.get(), pixel_image_size
);
593 *release_callback
= cc::SingleReleaseCallback::Create(
594 base::Bind(&PepperGraphics2DHost::ReleaseCallback
,
596 base::Passed(&shared_bitmap
),
598 texture_mailbox_modified_
= false;
602 void PepperGraphics2DHost::AttachedToNewLayer() {
603 texture_mailbox_modified_
= true;
606 int32_t PepperGraphics2DHost::Flush(PP_Resource
* old_image_data
) {
607 bool done_replace_contents
= false;
608 bool no_update_visible
= true;
609 bool is_plugin_visible
= true;
610 for (size_t i
= 0; i
< queued_operations_
.size(); i
++) {
611 QueuedOperation
& operation
= queued_operations_
[i
];
613 switch (operation
.type
) {
614 case QueuedOperation::PAINT
:
615 ExecutePaintImageData(operation
.paint_image
.get(),
618 operation
.paint_src_rect
,
621 case QueuedOperation::SCROLL
:
622 ExecuteScroll(operation
.scroll_clip_rect
,
627 case QueuedOperation::REPLACE
:
628 // Since the out parameter |old_image_data| takes ownership of the
629 // reference, if there are more than one ReplaceContents calls queued
630 // the first |old_image_data| will get overwritten and leaked. So we
631 // only supply this for the first call.
632 ExecuteReplaceContents(operation
.replace_image
.get(),
634 done_replace_contents
? NULL
: old_image_data
);
635 done_replace_contents
= true;
639 // For correctness with accelerated compositing, we must issue an invalidate
640 // on the full op_rect even if it is partially or completely off-screen.
641 // However, if we issue an invalidate for a clipped-out region, WebKit will
642 // do nothing and we won't get any ViewFlushedPaint calls, leaving our
643 // callback stranded. So we still need to check whether the repainted area
644 // is visible to determine how to deal with the callback.
645 if (bound_instance_
&& !op_rect
.IsEmpty()) {
646 gfx::Point
scroll_delta(operation
.scroll_dx
, operation
.scroll_dy
);
647 if (!ConvertToLogicalPixels(scale_
,
649 operation
.type
== QueuedOperation::SCROLL
652 // Conversion requires falling back to InvalidateRect.
653 operation
.type
= QueuedOperation::PAINT
;
656 gfx::Rect clip
= PP_ToGfxRect(bound_instance_
->view_data().clip_rect
);
657 is_plugin_visible
= !clip
.IsEmpty();
659 // Set |no_update_visible| to false if the change overlaps the visible
661 if (!gfx::IntersectRects(clip
, op_rect
).IsEmpty()) {
662 no_update_visible
= false;
665 // Notify the plugin of the entire change (op_rect), even if it is
666 // partially or completely off-screen.
667 if (operation
.type
== QueuedOperation::SCROLL
) {
668 bound_instance_
->ScrollRect(
669 scroll_delta
.x(), scroll_delta
.y(), op_rect
);
671 if (!op_rect
.IsEmpty())
672 bound_instance_
->InvalidateRect(op_rect
);
674 texture_mailbox_modified_
= true;
677 queued_operations_
.clear();
679 if (!bound_instance_
) {
680 // As promised in the API, we always schedule callback when unbound.
681 ScheduleOffscreenFlushAck();
682 } else if (no_update_visible
&& is_plugin_visible
&&
683 bound_instance_
->view_data().is_page_visible
) {
684 // There's nothing visible to invalidate so just schedule the callback to
685 // execute in the next round of the message loop.
686 ScheduleOffscreenFlushAck();
688 need_flush_ack_
= true;
691 if (bound_instance_
&& bound_instance_
->throttler() &&
692 bound_instance_
->throttler()->needs_representative_keyframe()) {
693 bound_instance_
->throttler()->OnImageFlush(image_data_
->GetMappedBitmap());
696 return PP_OK_COMPLETIONPENDING
;
699 void PepperGraphics2DHost::ExecutePaintImageData(PPB_ImageData_Impl
* image
,
702 const gfx::Rect
& src_rect
,
703 gfx::Rect
* invalidated_rect
) {
704 // Ensure the source image is mapped to read from it.
705 ImageDataAutoMapper
auto_mapper(image
);
706 if (!auto_mapper
.is_valid())
709 // Portion within the source image to cut out.
710 SkIRect src_irect
= {src_rect
.x(), src_rect
.y(), src_rect
.right(),
713 // Location within the backing store to copy to.
714 *invalidated_rect
= src_rect
;
715 invalidated_rect
->Offset(x
, y
);
716 SkRect dest_rect
= {SkIntToScalar(invalidated_rect
->x()),
717 SkIntToScalar(invalidated_rect
->y()),
718 SkIntToScalar(invalidated_rect
->right()),
719 SkIntToScalar(invalidated_rect
->bottom())};
721 if (image
->format() != image_data_
->format()) {
722 // Convert the image data if the format does not match.
723 ConvertImageData(image
, src_irect
, image_data_
.get(), dest_rect
);
725 // We're guaranteed to have a mapped canvas since we mapped it in Init().
726 SkCanvas
* backing_canvas
= image_data_
->GetCanvas();
728 // We want to replace the contents of the bitmap rather than blend.
730 paint
.setXfermodeMode(SkXfermode::kSrc_Mode
);
731 backing_canvas
->drawBitmapRect(
732 *image
->GetMappedBitmap(), &src_irect
, dest_rect
, &paint
);
736 void PepperGraphics2DHost::ExecuteScroll(const gfx::Rect
& clip
,
739 gfx::Rect
* invalidated_rect
) {
740 gfx::ScrollCanvas(image_data_
->GetCanvas(), clip
, gfx::Vector2d(dx
, dy
));
741 *invalidated_rect
= clip
;
744 void PepperGraphics2DHost::ExecuteReplaceContents(PPB_ImageData_Impl
* image
,
745 gfx::Rect
* invalidated_rect
,
746 PP_Resource
* old_image_data
) {
747 if (image
->format() != image_data_
->format()) {
748 DCHECK(image
->width() == image_data_
->width() &&
749 image
->height() == image_data_
->height());
750 // Convert the image data if the format does not match.
751 SkIRect src_irect
= {0, 0, image
->width(), image
->height()};
752 SkRect dest_rect
= {SkIntToScalar(0), SkIntToScalar(0),
753 SkIntToScalar(image_data_
->width()),
754 SkIntToScalar(image_data_
->height())};
755 ConvertImageData(image
, src_irect
, image_data_
.get(), dest_rect
);
757 // The passed-in image may not be mapped in our process, and we need to
758 // guarantee that the current backing store is always mapped.
763 *old_image_data
= image_data_
->GetReference();
767 gfx::Rect(0, 0, image_data_
->width(), image_data_
->height());
770 void PepperGraphics2DHost::SendFlushAck() {
771 host()->SendReply(flush_reply_context_
, PpapiPluginMsg_Graphics2D_FlushAck());
774 void PepperGraphics2DHost::SendOffscreenFlushAck() {
775 DCHECK(offscreen_flush_pending_
);
777 // We must clear this flag before issuing the callback. It will be
778 // common for the plugin to issue another invalidate in response to a flush
779 // callback, and we don't want to think that a callback is already pending.
780 offscreen_flush_pending_
= false;
784 void PepperGraphics2DHost::ScheduleOffscreenFlushAck() {
785 offscreen_flush_pending_
= true;
786 base::MessageLoop::current()->PostDelayedTask(
788 base::Bind(&PepperGraphics2DHost::SendOffscreenFlushAck
, AsWeakPtr()),
789 base::TimeDelta::FromMilliseconds(kOffscreenCallbackDelayMs
));
792 bool PepperGraphics2DHost::HasPendingFlush() const {
793 return need_flush_ack_
|| offscreen_flush_pending_
;
797 bool PepperGraphics2DHost::ConvertToLogicalPixels(float scale
,
800 if (scale
== 1.0f
|| scale
<= 0.0f
)
803 gfx::Rect original_rect
= *op_rect
;
804 // Take the enclosing rectangle after scaling so a rectangle scaled down then
805 // scaled back up by the inverse scale would fully contain the entire area
806 // affected by the original rectangle.
807 *op_rect
= gfx::ToEnclosingRect(gfx::ScaleRect(*op_rect
, scale
));
809 gfx::Point original_delta
= *delta
;
810 float inverse_scale
= 1.0f
/ scale
;
811 *delta
= gfx::ToFlooredPoint(gfx::ScalePoint(*delta
, scale
));
813 gfx::Rect inverse_scaled_rect
=
814 gfx::ToEnclosingRect(gfx::ScaleRect(*op_rect
, inverse_scale
));
815 if (original_rect
!= inverse_scaled_rect
)
817 gfx::Point inverse_scaled_point
=
818 gfx::ToFlooredPoint(gfx::ScalePoint(*delta
, inverse_scale
));
819 if (original_delta
!= inverse_scaled_point
)
826 } // namespace content