third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.cpp

   1 // Copyright 2014 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
   7 #include "platform/graphics/RecordingImageBufferSurface.h"
   8
   9 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
  10 #include "platform/graphics/GraphicsContext.h"
  11 #include "platform/graphics/ImageBuffer.h"
  12 #include "public/platform/Platform.h"
  13 #include "third_party/skia/include/core/SkCanvas.h"
  14 #include "third_party/skia/include/core/SkPictureRecorder.h"
  15 #include "wtf/PassOwnPtr.h"
  16 #include "wtf/PassRefPtr.h"
  17
  18 namespace blink {
  19
  20 RecordingImageBufferSurface::RecordingImageBufferSurface(const IntSize& size, PassOwnPtr<RecordingImageBufferFallbackSurfaceFactory> fallbackFactory, OpacityMode opacityMode)
  21     : ImageBufferSurface(size, opacityMode)
  22     , m_imageBuffer(0)
  23     , m_currentFramePixelCount(0)
  24     , m_previousFramePixelCount(0)
  25     , m_frameWasCleared(true)
  26     , m_didRecordDrawCommandsInCurrentFrame(false)
  27     , m_currentFrameHasExpensiveOp(false)
  28     , m_previousFrameHasExpensiveOp(false)
  29     , m_fallbackFactory(fallbackFactory)
  30 {
  31     initializeCurrentFrame();
  32 }
  33
  34 RecordingImageBufferSurface::~RecordingImageBufferSurface()
  35 { }
  36
  37 bool RecordingImageBufferSurface::initializeCurrentFrame()
  38 {
  39     static SkRTreeFactory rTreeFactory;
  40     m_currentFrame = adoptPtr(new SkPictureRecorder);
  41     m_currentFrame->beginRecording(size().width(), size().height(), &rTreeFactory);
  42     if (m_imageBuffer) {
  43         m_imageBuffer->resetCanvas(m_currentFrame->getRecordingCanvas());
  44     }
  45     m_didRecordDrawCommandsInCurrentFrame = false;
  46     m_currentFrameHasExpensiveOp = false;
  47     m_currentFramePixelCount = 0;
  48     return true;
  49 }
  50
  51 void RecordingImageBufferSurface::setImageBuffer(ImageBuffer* imageBuffer)
  52 {
  53     m_imageBuffer = imageBuffer;
  54     if (m_currentFrame && m_imageBuffer) {
  55         m_imageBuffer->resetCanvas(m_currentFrame->getRecordingCanvas());
  56     }
  57     if (m_fallbackSurface) {
  58         m_fallbackSurface->setImageBuffer(imageBuffer);
  59     }
  60 }
  61
  62 bool RecordingImageBufferSurface::writePixels(const SkImageInfo& origInfo, const void* pixels, size_t rowBytes, int x, int y)
  63 {
  64     if (!m_fallbackSurface) {
  65         if (x <= 0 && y <= 0 && x + origInfo.width() >= size().width() && y + origInfo.height() >= size().height()) {
  66             willOverwriteCanvas();
  67         }
  68         fallBackToRasterCanvas();
  69     }
  70     return m_fallbackSurface->writePixels(origInfo, pixels, rowBytes, x, y);
  71 }
  72
  73 void RecordingImageBufferSurface::fallBackToRasterCanvas()
  74 {
  75     if (m_fallbackSurface) {
  76         ASSERT(!m_currentFrame);
  77         return;
  78     }
  79
  80     m_fallbackSurface = m_fallbackFactory->createSurface(size(), opacityMode());
  81     m_fallbackSurface->setImageBuffer(m_imageBuffer);
  82
  83     if (m_previousFrame) {
  84         m_previousFrame->playback(m_fallbackSurface->canvas());
  85         m_previousFrame.clear();
  86     }
  87
  88     if (m_currentFrame) {
  89         RefPtr<SkPicture> currentPicture = adoptRef(m_currentFrame->endRecording());
  90         currentPicture->playback(m_fallbackSurface->canvas());
  91         m_currentFrame.clear();
  92     }
  93
  94     if (m_imageBuffer) {
  95         m_imageBuffer->resetCanvas(m_fallbackSurface->canvas());
  96     }
  97
  98 }
  99
 100 PassRefPtr<SkImage> RecordingImageBufferSurface::newImageSnapshot()
 101 {
 102     if (!m_fallbackSurface)
 103         fallBackToRasterCanvas();
 104     return m_fallbackSurface->newImageSnapshot();
 105 }
 106
 107 SkCanvas* RecordingImageBufferSurface::canvas()
 108 {
 109     if (m_fallbackSurface)
 110         return m_fallbackSurface->canvas();
 111
 112     ASSERT(m_currentFrame->getRecordingCanvas());
 113     return m_currentFrame->getRecordingCanvas();
 114 }
 115
 116 void RecordingImageBufferSurface::disableDeferral()
 117 {
 118     if (!m_fallbackSurface)
 119         fallBackToRasterCanvas();
 120 }
 121
 122 PassRefPtr<SkPicture> RecordingImageBufferSurface::getPicture()
 123 {
 124     if (m_fallbackSurface)
 125         return nullptr;
 126
 127     bool canUsePicture = finalizeFrameInternal();
 128     m_imageBuffer->didFinalizeFrame();
 129
 130     if (canUsePicture) {
 131         return m_previousFrame;
 132     }
 133
 134     if (!m_fallbackSurface)
 135         fallBackToRasterCanvas();
 136     return nullptr;
 137 }
 138
 139 void RecordingImageBufferSurface::finalizeFrame(const FloatRect &dirtyRect)
 140 {
 141     if (m_fallbackSurface) {
 142         m_fallbackSurface->finalizeFrame(dirtyRect);
 143         return;
 144     }
 145
 146     if (!finalizeFrameInternal())
 147         fallBackToRasterCanvas();
 148 }
 149
 150 void RecordingImageBufferSurface::flush()
 151 {
 152     if (!m_fallbackSurface)
 153         fallBackToRasterCanvas();
 154     m_fallbackSurface->flush();
 155 }
 156
 157 void RecordingImageBufferSurface::willOverwriteCanvas()
 158 {
 159     m_frameWasCleared = true;
 160     m_previousFrame.clear();
 161     m_previousFrameHasExpensiveOp = false;
 162     m_previousFramePixelCount = 0;
 163     if (m_didRecordDrawCommandsInCurrentFrame) {
 164         // Discard previous draw commands
 165         adoptRef(m_currentFrame->endRecording());
 166         initializeCurrentFrame();
 167     }
 168 }
 169
 170 void RecordingImageBufferSurface::didDraw(const FloatRect& rect)
 171 {
 172     m_didRecordDrawCommandsInCurrentFrame = true;
 173     IntRect pixelBounds = enclosingIntRect(rect);
 174     m_currentFramePixelCount += pixelBounds.width() * pixelBounds.height();
 175 }
 176
 177 bool RecordingImageBufferSurface::finalizeFrameInternal()
 178 {
 179     ASSERT(!m_fallbackSurface);
 180     ASSERT(m_currentFrame);
 181     ASSERT(m_currentFrame->getRecordingCanvas());
 182
 183     if (!m_imageBuffer->isDirty()) {
 184         if (!m_previousFrame) {
 185             // Create an initial blank frame
 186             m_previousFrame = adoptRef(m_currentFrame->endRecording());
 187             initializeCurrentFrame();
 188         }
 189         return m_currentFrame;
 190     }
 191
 192     if (!m_frameWasCleared || m_currentFrame->getRecordingCanvas()->getSaveCount() > ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth) {
 193         return false;
 194     }
 195
 196     m_previousFrame = adoptRef(m_currentFrame->endRecording());
 197     m_previousFrameHasExpensiveOp = m_currentFrameHasExpensiveOp;
 198     m_previousFramePixelCount = m_currentFramePixelCount;
 199     if (!initializeCurrentFrame())
 200         return false;
 201
 202     m_frameWasCleared = false;
 203     return true;
 204 }
 205
 206 void RecordingImageBufferSurface::draw(GraphicsContext* context, const FloatRect& destRect, const FloatRect& srcRect, SkXfermode::Mode op)
 207 {
 208     if (m_fallbackSurface) {
 209         m_fallbackSurface->draw(context, destRect, srcRect, op);
 210         return;
 211     }
 212
 213     RefPtr<SkPicture> picture = getPicture();
 214     if (picture) {
 215         context->compositePicture(picture.get(), destRect, srcRect, op);
 216     } else {
 217         ImageBufferSurface::draw(context, destRect, srcRect, op);
 218     }
 219 }
 220
 221 bool RecordingImageBufferSurface::isExpensiveToPaint()
 222 {
 223     if (m_fallbackSurface)
 224         return m_fallbackSurface->isExpensiveToPaint();
 225
 226     if (m_didRecordDrawCommandsInCurrentFrame) {
 227         if (m_currentFrameHasExpensiveOp)
 228             return true;
 229
 230         if (m_currentFramePixelCount >= (size().width() * size().height() * ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold))
 231             return true;
 232
 233         if (m_frameWasCleared)
 234             return false; // early exit because previous frame is overdrawn
 235     }
 236
 237     if (m_previousFrame) {
 238         if (m_previousFrameHasExpensiveOp)
 239             return true;
 240
 241         if (m_previousFramePixelCount >= (size().width() * size().height() * ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold))
 242             return true;
 243     }
 244
 245     return false;
 246 }
 247
 248 const SkBitmap& RecordingImageBufferSurface::deprecatedBitmapForOverwrite()
 249 {
 250     if (!m_fallbackSurface) {
 251         willOverwriteCanvas();
 252         fallBackToRasterCanvas();
 253     }
 254     return m_fallbackSurface->deprecatedBitmapForOverwrite();
 255 }
 256
 257 // Fallback passthroughs
 258
 259 bool RecordingImageBufferSurface::restore()
 260 {
 261     if (m_fallbackSurface)
 262         return m_fallbackSurface->restore();
 263     return ImageBufferSurface::restore();
 264 }
 265
 266 WebLayer* RecordingImageBufferSurface::layer() const
 267 {
 268     if (m_fallbackSurface)
 269         return m_fallbackSurface->layer();
 270     return ImageBufferSurface::layer();
 271 }
 272
 273 bool RecordingImageBufferSurface::isAccelerated() const
 274 {
 275     if (m_fallbackSurface)
 276         return m_fallbackSurface->isAccelerated();
 277     return ImageBufferSurface::isAccelerated();
 278 }
 279
 280 void RecordingImageBufferSurface::setIsHidden(bool hidden)
 281 {
 282     if (m_fallbackSurface)
 283         m_fallbackSurface->setIsHidden(hidden);
 284     else
 285         ImageBufferSurface::setIsHidden(hidden);
 286 }
 287
 288 } // namespace blink