third_party/WebKit/Source/web/PageOverlayTest.cpp

   1 // Copyright 2015 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.
   4
   5 #include "config.h"
   6 #include "web/PageOverlay.h"
   7
   8 #include "core/frame/FrameView.h"
   9 #include "core/layout/LayoutView.h"
  10 #include "platform/graphics/Color.h"
  11 #include "platform/graphics/GraphicsContext.h"
  12 #include "platform/graphics/paint/DisplayItemList.h"
  13 #include "platform/graphics/paint/DrawingRecorder.h"
  14 #include "public/platform/Platform.h"
  15 #include "public/platform/WebCanvas.h"
  16 #include "public/platform/WebThread.h"
  17 #include "public/web/WebSettings.h"
  18 #include "third_party/skia/include/core/SkBitmap.h"
  19 #include "third_party/skia/include/core/SkCanvas.h"
  20 #include "third_party/skia/include/core/SkColor.h"
  21 #include "third_party/skia/include/core/SkPaint.h"
  22 #include "web/WebGraphicsContextImpl.h"
  23 #include "web/WebLocalFrameImpl.h"
  24 #include "web/WebViewImpl.h"
  25 #include "web/tests/FrameTestHelpers.h"
  26 #include <gmock/gmock.h>
  27 #include <gtest/gtest.h>
  28
  29 using testing::_;
  30 using testing::AtLeast;
  31 using testing::Property;
  32
  33 namespace blink {
  34 namespace {
  35
  36 static const int viewportWidth = 800;
  37 static const int viewportHeight = 600;
  38
  39 // These unit tests cover both PageOverlay and PageOverlayList.
  40
  41 void enableAcceleratedCompositing(WebSettings* settings)
  42 {
  43     settings->setAcceleratedCompositingEnabled(true);
  44 }
  45
  46 void disableAcceleratedCompositing(WebSettings* settings)
  47 {
  48     settings->setAcceleratedCompositingEnabled(false);
  49 }
  50
  51 class PageOverlayTest : public ::testing::Test {
  52 protected:
  53     enum CompositingMode { AcceleratedCompositing, UnacceleratedCompositing };
  54
  55     void initialize(CompositingMode compositingMode)
  56     {
  57         m_helper.initialize(
  58             false /* enableJavascript */, nullptr /* webFrameClient */, nullptr /* webViewClient */,
  59             compositingMode == AcceleratedCompositing ? enableAcceleratedCompositing : disableAcceleratedCompositing);
  60         webViewImpl()->resize(WebSize(viewportWidth, viewportHeight));
  61         webViewImpl()->layout();
  62         ASSERT_EQ(compositingMode == AcceleratedCompositing, webViewImpl()->isAcceleratedCompositingActive());
  63     }
  64
  65     WebViewImpl* webViewImpl() const { return m_helper.webViewImpl(); }
  66
  67     template <typename OverlayType>
  68     void runPageOverlayTestWithAcceleratedCompositing();
  69
  70 private:
  71     FrameTestHelpers::WebViewHelper m_helper;
  72 };
  73
  74 // PageOverlay that uses a WebCanvas to draw a solid color.
  75 class SimpleCanvasOverlay : public PageOverlay::Delegate {
  76 public:
  77     SimpleCanvasOverlay(SkColor color) : m_color(color) { }
  78
  79     void paintPageOverlay(WebGraphicsContext* context, const WebSize& size) override
  80     {
  81         WebFloatRect rect(0, 0, size.width, size.height);
  82         WebCanvas* canvas = context->beginDrawing(rect);
  83         SkPaint paint;
  84         paint.setColor(m_color);
  85         paint.setStyle(SkPaint::kFill_Style);
  86         canvas->drawRectCoords(0, 0, size.width, size.height, paint);
  87         context->endDrawing();
  88     }
  89
  90 private:
  91     SkColor m_color;
  92 };
  93
  94 // PageOverlay that uses the underlying blink::GraphicsContext to paint a
  95 // solid color.
  96 class PrivateGraphicsContextOverlay : public PageOverlay::Delegate {
  97 public:
  98     PrivateGraphicsContextOverlay(Color color) : m_color(color) { }
  99
 100     void paintPageOverlay(WebGraphicsContext* context, const WebSize& size) override
 101     {
 102         GraphicsContext& graphicsContext = toWebGraphicsContextImpl(context)->graphicsContext();
 103         if (DrawingRecorder::useCachedDrawingIfPossible(graphicsContext, *this, DisplayItem::PageOverlay))
 104             return;
 105         FloatRect rect(0, 0, size.width, size.height);
 106         DrawingRecorder drawingRecorder(graphicsContext, *this, DisplayItem::PageOverlay, rect);
 107         graphicsContext.fillRect(rect, m_color);
 108     }
 109
 110     DisplayItemClient displayItemClient() const { return toDisplayItemClient(this); }
 111     String debugName() const { return "PrivateGraphicsContextOverlay"; }
 112
 113 private:
 114     Color m_color;
 115 };
 116
 117 template <bool(*getter)(), void(*setter)(bool)>
 118 class RuntimeFeatureChange {
 119 public:
 120     RuntimeFeatureChange(bool newValue) : m_oldValue(getter()) { setter(newValue); }
 121     ~RuntimeFeatureChange() { setter(m_oldValue); }
 122 private:
 123     bool m_oldValue;
 124 };
 125
 126 class MockCanvas : public SkCanvas {
 127 public:
 128     MockCanvas(int width, int height) : SkCanvas(width, height) { }
 129     MOCK_METHOD2(onDrawRect, void(const SkRect&, const SkPaint&));
 130 };
 131
 132 template <typename OverlayType>
 133 void PageOverlayTest::runPageOverlayTestWithAcceleratedCompositing()
 134 {
 135     initialize(AcceleratedCompositing);
 136     webViewImpl()->layerTreeView()->setViewportSize(WebSize(viewportWidth, viewportHeight));
 137
 138     OwnPtr<PageOverlay> pageOverlay = PageOverlay::create(webViewImpl(), new OverlayType(SK_ColorYELLOW));
 139     pageOverlay->update();
 140     webViewImpl()->layout();
 141
 142     // Ideally, we would get results from the compositor that showed that this
 143     // page overlay actually winds up getting drawn on top of the rest.
 144     // For now, we just check that the GraphicsLayer will draw the right thing.
 145
 146     MockCanvas canvas(viewportWidth, viewportHeight);
 147     EXPECT_CALL(canvas, onDrawRect(_, _)).Times(AtLeast(0));
 148     EXPECT_CALL(canvas, onDrawRect(SkRect::MakeWH(viewportWidth, viewportHeight), Property(&SkPaint::getColor, SK_ColorYELLOW)));
 149
 150     GraphicsLayer* graphicsLayer = pageOverlay->graphicsLayer();
 151     WebRect rect(0, 0, viewportWidth, viewportHeight);
 152
 153     // Paint the layer with a null canvas to get a display list, and then
 154     // replay that onto the mock canvas for examination.
 155     GraphicsContext graphicsContext(graphicsLayer->displayItemList());
 156     graphicsLayer->paint(graphicsContext, rect);
 157
 158     graphicsContext.beginRecording(IntRect(rect));
 159     graphicsLayer->displayItemList()->commitNewDisplayItemsAndReplay(graphicsContext);
 160     graphicsContext.endRecording()->playback(&canvas);
 161 }
 162
 163 TEST_F(PageOverlayTest, SimpleCanvasOverlay_AcceleratedCompositing)
 164 {
 165     runPageOverlayTestWithAcceleratedCompositing<SimpleCanvasOverlay>();
 166 }
 167
 168 TEST_F(PageOverlayTest, PrivateGraphicsContextOverlay_AcceleratedCompositing)
 169 {
 170     runPageOverlayTestWithAcceleratedCompositing<PrivateGraphicsContextOverlay>();
 171 }
 172
 173 } // namespace
 174 } // namespace blink