| // 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/renderer/pepper/pepper_graphics_2d_host.h" |
| |
| #include "base/basictypes.h" |
| #include "base/message_loop/message_loop.h" |
| #include "content/renderer/pepper/gfx_conversion.h" |
| #include "content/renderer/pepper/mock_renderer_ppapi_host.h" |
| #include "content/renderer/pepper/ppb_image_data_impl.h" |
| #include "ppapi/shared_impl/ppb_view_shared.h" |
| #include "ppapi/shared_impl/proxy_lock.h" |
| #include "ppapi/shared_impl/test_globals.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/WebKit/public/platform/WebCanvas.h" |
| #include "third_party/skia/include/core/SkCanvas.h" |
| #include "ui/gfx/point.h" |
| #include "ui/gfx/rect.h" |
| |
| using blink::WebCanvas; |
| |
| namespace content { |
| |
| class PepperGraphics2DHostTest : public testing::Test { |
| public: |
| static bool ConvertToLogicalPixels(float scale, |
| gfx::Rect* op_rect, |
| gfx::Point* delta) { |
| return PepperGraphics2DHost::ConvertToLogicalPixels(scale, op_rect, delta); |
| } |
| |
| PepperGraphics2DHostTest() |
| : message_loop_(base::MessageLoop::TYPE_DEFAULT), |
| renderer_ppapi_host_(NULL, 12345) {} |
| |
| virtual ~PepperGraphics2DHostTest() { |
| ppapi::ProxyAutoLock proxy_lock; |
| host_.reset(); |
| } |
| |
| void Init(PP_Instance instance, |
| const PP_Size& backing_store_size, |
| const PP_Rect& plugin_rect) { |
| renderer_view_data_.rect = plugin_rect; |
| PluginViewUpdated(); |
| test_globals_.GetResourceTracker()->DidCreateInstance(instance); |
| scoped_refptr<PPB_ImageData_Impl> backing_store( |
| new PPB_ImageData_Impl(instance, PPB_ImageData_Impl::ForTest())); |
| host_.reset(PepperGraphics2DHost::Create( |
| &renderer_ppapi_host_, instance, 12345, backing_store_size, PP_FALSE, |
| backing_store)); |
| DCHECK(host_.get()); |
| } |
| |
| void PaintImageData(PPB_ImageData_Impl* image_data) { |
| ppapi::HostResource image_data_resource; |
| image_data_resource.SetHostResource(image_data->pp_instance(), |
| image_data->pp_resource()); |
| host_->OnHostMsgPaintImageData(NULL, image_data_resource, |
| PP_Point(), false, PP_Rect()); |
| } |
| |
| void SetOffset(const PP_Point& point) { |
| host_->OnHostMsgSetOffset(NULL, point); |
| } |
| |
| void Flush() { |
| ppapi::host::HostMessageContext context( |
| ppapi::proxy::ResourceMessageCallParams(host_->pp_resource(), 0)); |
| host_->OnHostMsgFlush(&context, plugin_view_data_); |
| host_->ViewFlushedPaint(); |
| host_->SendOffscreenFlushAck(); |
| } |
| |
| void PaintToWebCanvas(SkBitmap* bitmap) { |
| scoped_ptr<WebCanvas> canvas(new WebCanvas(*bitmap)); |
| gfx::Rect plugin_rect(PP_ToGfxRect(renderer_view_data_.rect)); |
| host_->Paint(canvas.get(), plugin_rect, |
| gfx::Rect(0, 0, plugin_rect.width(), plugin_rect.height())); |
| } |
| |
| void DidChangeView(const PP_Rect& plugin_rect) { |
| renderer_view_data_.rect = plugin_rect; |
| host_->DidChangeView(renderer_view_data_); |
| } |
| |
| void PluginViewUpdated() { |
| plugin_view_data_ = renderer_view_data_; |
| } |
| |
| void SetResizeMode(PP_Graphics2D_Dev_ResizeMode resize_mode) { |
| host_->OnHostMsgSetResizeMode(NULL, resize_mode); |
| } |
| |
| void ResetPageBitmap(SkBitmap* bitmap) { |
| PP_Rect plugin_rect = renderer_view_data_.rect; |
| int width = plugin_rect.point.x + plugin_rect.size.width; |
| int height = plugin_rect.point.y + plugin_rect.size.height; |
| if (bitmap->isNull() || bitmap->width() != width || |
| bitmap->height() != height) { |
| bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); |
| bitmap->allocPixels(); |
| } |
| bitmap->eraseColor(0); |
| } |
| |
| private: |
| ppapi::ViewData renderer_view_data_; |
| ppapi::ViewData plugin_view_data_; |
| scoped_ptr<PepperGraphics2DHost> host_; |
| base::MessageLoop message_loop_; |
| MockRendererPpapiHost renderer_ppapi_host_; |
| ppapi::TestGlobals test_globals_; |
| }; |
| |
| TEST_F(PepperGraphics2DHostTest, ConvertToLogicalPixels) { |
| static const struct { |
| int x1; |
| int y1; |
| int w1; |
| int h1; |
| int x2; |
| int y2; |
| int w2; |
| int h2; |
| int dx1; |
| int dy1; |
| int dx2; |
| int dy2; |
| float scale; |
| bool result; |
| } tests[] = { |
| { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.0, true }, |
| { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.0, true }, |
| { 0, 0, 4, 4, 0, 0, 2, 2, 0, 0, 0, 0, 0.5, true }, |
| { 1, 1, 4, 4, 0, 0, 3, 3, 0, 0, 0, 0, 0.5, false }, |
| { 53, 75, 100, 100, 53, 75, 100, 100, 0, 0, 0, 0, 1.0, true }, |
| { 53, 75, 100, 100, 106, 150, 200, 200, 0, 0, 0, 0, 2.0, true }, |
| { 53, 75, 100, 100, 26, 37, 51, 51, 0, 0, 0, 0, 0.5, false }, |
| { 53, 74, 100, 100, 26, 37, 51, 50, 0, 0, 0, 0, 0.5, false }, |
| { -1, -1, 100, 100, -1, -1, 51, 51, 0, 0, 0, 0, 0.5, false }, |
| { -2, -2, 100, 100, -1, -1, 50, 50, 4, -4, 2, -2, 0.5, true }, |
| { -101, -100, 50, 50, -51, -50, 26, 25, 0, 0, 0, 0, 0.5, false }, |
| { 10, 10, 20, 20, 5, 5, 10, 10, 0, 0, 0, 0, 0.5, true }, |
| // Cannot scroll due to partial coverage on sides |
| { 11, 10, 20, 20, 5, 5, 11, 10, 0, 0, 0, 0, 0.5, false }, |
| // Can scroll since backing store is actually smaller/scaling up |
| { 11, 20, 100, 100, 22, 40, 200, 200, 7, 3, 14, 6, 2.0, true }, |
| // Can scroll due to delta and bounds being aligned |
| { 10, 10, 20, 20, 5, 5, 10, 10, 6, 4, 3, 2, 0.5, true }, |
| // Cannot scroll due to dx |
| { 10, 10, 20, 20, 5, 5, 10, 10, 5, 4, 2, 2, 0.5, false }, |
| // Cannot scroll due to dy |
| { 10, 10, 20, 20, 5, 5, 10, 10, 6, 3, 3, 1, 0.5, false }, |
| // Cannot scroll due to top |
| { 10, 11, 20, 20, 5, 5, 10, 11, 6, 4, 3, 2, 0.5, false }, |
| // Cannot scroll due to left |
| { 7, 10, 20, 20, 3, 5, 11, 10, 6, 4, 3, 2, 0.5, false }, |
| // Cannot scroll due to width |
| { 10, 10, 21, 20, 5, 5, 11, 10, 6, 4, 3, 2, 0.5, false }, |
| // Cannot scroll due to height |
| { 10, 10, 20, 51, 5, 5, 10, 26, 6, 4, 3, 2, 0.5, false }, |
| // Check negative scroll deltas |
| { 10, 10, 20, 20, 5, 5, 10, 10, -6, -4, -3, -2, 0.5, true }, |
| { 10, 10, 20, 20, 5, 5, 10, 10, -6, -3, -3, -1, 0.5, false }, |
| }; |
| for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) { |
| gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1); |
| gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2); |
| gfx::Rect orig = r1; |
| gfx::Point delta(tests[i].dx1, tests[i].dy1); |
| bool res = ConvertToLogicalPixels(tests[i].scale, &r1, &delta); |
| EXPECT_EQ(r2.ToString(), r1.ToString()); |
| EXPECT_EQ(res, tests[i].result); |
| if (res) { |
| EXPECT_EQ(delta, gfx::Point(tests[i].dx2, tests[i].dy2)); |
| } |
| // Reverse the scale and ensure all the original pixels are still inside |
| // the result. |
| ConvertToLogicalPixels(1.0f / tests[i].scale, &r1, NULL); |
| EXPECT_TRUE(r1.Contains(orig)); |
| } |
| } |
| |
| TEST_F(PepperGraphics2DHostTest, SetOffset) { |
| ppapi::ProxyAutoLock proxy_lock; |
| |
| // Initialize the backing store. |
| PP_Instance instance = 12345; |
| PP_Size backing_store_size = { 300, 300 }; |
| PP_Rect plugin_rect = PP_MakeRectFromXYWH(0, 0, 500, 500); |
| Init(instance, backing_store_size, plugin_rect); |
| |
| // Paint the entire backing store red. |
| scoped_refptr<PPB_ImageData_Impl> image_data( |
| new PPB_ImageData_Impl(instance, PPB_ImageData_Impl::ForTest())); |
| image_data->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(), |
| backing_store_size.width, |
| backing_store_size.height, |
| true); |
| { |
| ImageDataAutoMapper auto_mapper(image_data.get()); |
| image_data->GetMappedBitmap()->eraseColor( |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| } |
| PaintImageData(image_data.get()); |
| Flush(); |
| |
| // Set up the actual and expected bitmaps/canvas. |
| SkBitmap actual_bitmap; |
| ResetPageBitmap(&actual_bitmap); |
| SkBitmap expected_bitmap; |
| ResetPageBitmap(&expected_bitmap); |
| |
| // Paint the backing store to the canvas. |
| PaintToWebCanvas(&actual_bitmap); |
| expected_bitmap.eraseArea( |
| SkIRect::MakeWH(backing_store_size.width, backing_store_size.height), |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Set the offset. |
| PP_Point offset = { 20, 20 }; |
| SetOffset(offset); |
| ResetPageBitmap(&actual_bitmap); |
| PaintToWebCanvas(&actual_bitmap); |
| // No flush has occurred so the result should be the same. |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Flush the offset and the location of the rectangle should have shifted. |
| Flush(); |
| ResetPageBitmap(&actual_bitmap); |
| PaintToWebCanvas(&actual_bitmap); |
| ResetPageBitmap(&expected_bitmap); |
| expected_bitmap.eraseArea( |
| SkIRect::MakeXYWH(offset.x, offset.y, |
| backing_store_size.width, backing_store_size.height), |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| } |
| |
| TEST_F(PepperGraphics2DHostTest, ResizeModeDefault) { |
| ppapi::ProxyAutoLock proxy_lock; |
| |
| // Initialize the backing store. |
| PP_Instance instance = 12345; |
| PP_Size backing_store_size = { 300, 300 }; |
| PP_Rect plugin_rect = PP_MakeRectFromXYWH(0, 0, 300, 300); |
| Init(instance, backing_store_size, plugin_rect); |
| |
| // Paint the entire backing store red. |
| scoped_refptr<PPB_ImageData_Impl> image_data( |
| new PPB_ImageData_Impl(instance, PPB_ImageData_Impl::ForTest())); |
| image_data->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(), |
| backing_store_size.width, |
| backing_store_size.height, |
| true); |
| { |
| ImageDataAutoMapper auto_mapper(image_data.get()); |
| image_data->GetMappedBitmap()->eraseColor( |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| } |
| PaintImageData(image_data.get()); |
| Flush(); |
| |
| // Set up the actual and expected bitmaps/canvas. |
| SkBitmap actual_bitmap; |
| ResetPageBitmap(&actual_bitmap); |
| SkBitmap expected_bitmap; |
| ResetPageBitmap(&expected_bitmap); |
| |
| // Paint the backing store to the canvas. |
| PaintToWebCanvas(&actual_bitmap); |
| expected_bitmap.eraseArea( |
| SkIRect::MakeWH(backing_store_size.width, backing_store_size.height), |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Resize the plugin. |
| DidChangeView(PP_MakeRectFromXYWH(0, 0, 500, 500)); |
| // Paint the backing store again, it shouldn't have changed. |
| ResetPageBitmap(&actual_bitmap); |
| PaintToWebCanvas(&actual_bitmap); |
| ResetPageBitmap(&expected_bitmap); |
| expected_bitmap.eraseArea( |
| SkIRect::MakeWH(backing_store_size.width, backing_store_size.height), |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Let the plugin know about the updated view and reflush the original image. |
| PluginViewUpdated(); |
| PaintImageData(image_data.get()); |
| Flush(); |
| // Paint the backing store again, it shouldn't have changed. |
| ResetPageBitmap(&actual_bitmap); |
| PaintToWebCanvas(&actual_bitmap); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| } |
| |
| TEST_F(PepperGraphics2DHostTest, ResizeModeStretch) { |
| ppapi::ProxyAutoLock proxy_lock; |
| |
| // Initialize the backing store. |
| PP_Instance instance = 12345; |
| PP_Size backing_store_size = { 300, 300 }; |
| PP_Rect plugin_rect = PP_MakeRectFromXYWH(0, 0, 300, 300); |
| Init(instance, backing_store_size, plugin_rect); |
| SetResizeMode(PP_GRAPHICS2D_DEV_RESIZEMODE_STRETCH); |
| |
| // Paint the entire backing store red. |
| scoped_refptr<PPB_ImageData_Impl> image_data( |
| new PPB_ImageData_Impl(instance, PPB_ImageData_Impl::ForTest())); |
| image_data->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(), |
| backing_store_size.width, |
| backing_store_size.height, |
| true); |
| { |
| ImageDataAutoMapper auto_mapper(image_data.get()); |
| image_data->GetMappedBitmap()->eraseColor( |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| } |
| PaintImageData(image_data.get()); |
| Flush(); |
| |
| // Set up the actual and expected bitmaps/canvas. |
| SkBitmap actual_bitmap; |
| ResetPageBitmap(&actual_bitmap); |
| SkBitmap expected_bitmap; |
| ResetPageBitmap(&expected_bitmap); |
| |
| // Paint the backing store to the canvas. |
| PaintToWebCanvas(&actual_bitmap); |
| expected_bitmap.eraseArea( |
| SkIRect::MakeWH(backing_store_size.width, backing_store_size.height), |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Resize the plugin. |
| plugin_rect = PP_MakeRectFromXYWH(0, 0, 500, 500); |
| DidChangeView(plugin_rect); |
| ResetPageBitmap(&actual_bitmap); |
| ResetPageBitmap(&expected_bitmap); |
| |
| // Paint the backing store again, it should be stretched even though no new |
| // image has been flushed. |
| PaintToWebCanvas(&actual_bitmap); |
| expected_bitmap.eraseColor(SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Re-flush the original image data and paint it, it should be stretched as |
| // well. |
| PaintImageData(image_data.get()); |
| Flush(); |
| ResetPageBitmap(&actual_bitmap); |
| PaintToWebCanvas(&actual_bitmap); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| |
| // Let the plugin know about the updated view. |
| PluginViewUpdated(); |
| |
| // Now flush the image data again, it should be at the original size. |
| PaintImageData(image_data.get()); |
| Flush(); |
| ResetPageBitmap(&actual_bitmap); |
| PaintToWebCanvas(&actual_bitmap); |
| ResetPageBitmap(&expected_bitmap); |
| expected_bitmap.eraseArea( |
| SkIRect::MakeWH(backing_store_size.width, backing_store_size.height), |
| SkColorSetARGBMacro(255, 255, 0, 0)); |
| EXPECT_EQ(memcmp(expected_bitmap.getAddr(0, 0), |
| actual_bitmap.getAddr(0, 0), |
| expected_bitmap.getSize()), 0); |
| } |
| |
| } // namespace content |
