Make cc/paint have concrete types

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 64 matching lines @@
   std::unique_ptr<gfx::GpuMemoryBuffer> m_gpuMemoryBuffer;
 
   // The id of the CHROMIUM image.
   const GLuint m_imageId;
 
   // The id of the texture bound to the CHROMIUM image.
   const GLuint m_textureId;
 };
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
 
-static sk_sp<PaintSurface> createSkSurface(GrContext* gr,
-                                           const IntSize& size,
-                                           int msaaSampleCount,
-                                           OpacityMode opacityMode,
-                                           sk_sp<SkColorSpace> colorSpace,
-                                           SkColorType colorType,
-                                           bool* surfaceIsAccelerated) {
+static sk_sp<SkSurface> createSkSurface(GrContext* gr,
+                                        const IntSize& size,
+                                        int msaaSampleCount,
+                                        OpacityMode opacityMode,
+                                        sk_sp<SkColorSpace> colorSpace,
+                                        SkColorType colorType,
+                                        bool* surfaceIsAccelerated) {
   if (gr)
     gr->resetContext();
 
   SkAlphaType alphaType =
       (Opaque == opacityMode) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
   SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), colorType,
                                        alphaType, colorSpace);
   SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
-  sk_sp<PaintSurface> surface;
+  sk_sp<SkSurface> surface;
 
   if (gr) {
     *surfaceIsAccelerated = true;
-    surface = PaintSurface::MakeRenderTarget(
+    surface = SkSurface::MakeRenderTarget(
         gr, SkBudgeted::kNo, info, msaaSampleCount,
         Opaque == opacityMode ? 0 : &disableLCDProps);
   }
 
   if (!surface) {
     *surfaceIsAccelerated = false;
-    surface = PaintSurface::MakeRaster(
+    surface = SkSurface::MakeRaster(
         info, Opaque == opacityMode ? 0 : &disableLCDProps);
   }
 
   if (surface) {
     if (opacityMode == Opaque) {
       surface->getCanvas()->clear(SK_ColorBLACK);
     } else {
       surface->getCanvas()->clear(SK_ColorTRANSPARENT);
     }
   }
@@ skipping 45 matching lines @@
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
 
   m_layer.reset();
   DCHECK_EQ(0u, m_mailboxes.size());
 }
 
 void Canvas2DLayerBridge::startRecording() {
   DCHECK(m_isDeferralEnabled);
   m_recorder = WTF::wrapUnique(new PaintRecorder);
   PaintCanvas* canvas =
-      m_recorder->beginRecording(m_size.width(), m_size.height(), nullptr);
+      m_recorder->beginRecording(m_size.width(), m_size.height());
   // Always save an initial frame, to support resetting the top level matrix
   // and clip.
   canvas->save();
 
   if (m_imageBuffer) {
     m_imageBuffer->resetCanvas(canvas);
   }
   m_recordingPixelCount = 0;
 }
 
 void Canvas2DLayerBridge::setLoggerForTesting(std::unique_ptr<Logger> logger) {
   m_logger = std::move(logger);
 }
 
+void Canvas2DLayerBridge::ResetSurface() {
+  m_surfacePaintCanvas.reset();
+  m_surface.reset();
+}
+
 bool Canvas2DLayerBridge::shouldAccelerate(AccelerationHint hint) const {
   bool accelerate;
   if (m_softwareRenderingWhileHidden)
     accelerate = false;
   else if (m_accelerationMode == ForceAccelerationForTesting)
     accelerate = true;
   else if (m_accelerationMode == DisableAcceleration)
     accelerate = false;
   else
     accelerate = hint == PreferAcceleration ||
@@ skipping 288 matching lines @@
     return;
   }
 
   if (!isAccelerated()) {
     m_logger->reportHibernationEvent(
         HibernationAbortedDueToSwitchToUnacceleratedRendering);
     return;
   }
 
   TRACE_EVENT0("blink", "Canvas2DLayerBridge::hibernate");
-  sk_sp<PaintSurface> tempHibernationSurface =
-      PaintSurface::MakeRasterN32Premul(m_size.width(), m_size.height());
+  sk_sp<SkSurface> tempHibernationSurface =
+      SkSurface::MakeRasterN32Premul(m_size.width(), m_size.height());
   if (!tempHibernationSurface) {
     m_logger->reportHibernationEvent(HibernationAbortedDueToAllocationFailure);
     return;
   }
   // No HibernationEvent reported on success. This is on purppose to avoid
   // non-complementary stats. Each HibernationScheduled event is paired with
   // exactly one failure or exit event.
   flushRecordingOnly();
   // The following checks that the flush succeeded, which should always be the
   // case because flushRecordingOnly should only fail it it fails to allocate
   // a surface, and we have an early exit at the top of this function for when
   // 'this' does not already have a surface.
   DCHECK(!m_haveRecordedDrawCommands);
-  PaintFlags copyPaint;
+  SkPaint copyPaint;
   copyPaint.setBlendMode(SkBlendMode::kSrc);
   m_surface->draw(tempHibernationSurface->getCanvas(), 0, 0,
                   &copyPaint);  // GPU readback
   m_hibernationImage = tempHibernationSurface->makeImageSnapshot();
-  m_surface.reset();  // destroy the GPU-backed buffer
+  ResetSurface();
   m_layer->clearTexture();
 #if USE_IOSURFACE_FOR_2D_CANVAS
   clearCHROMIUMImageCache();
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
   m_logger->didStartHibernating();
 }
 
 sk_sp<SkColorSpace> Canvas2DLayerBridge::skSurfaceColorSpace() const {
   if (m_skSurfacesUseColorSpace)
     return m_colorSpace.ToSkColorSpace();
   return nullptr;
 }
 
 void Canvas2DLayerBridge::reportSurfaceCreationFailure() {
   if (!m_surfaceCreationFailedAtLeastOnce) {
     // Only count the failure once per instance so that the histogram may
     // reflect the proportion of Canvas2DLayerBridge instances with surface
     // allocation failures.
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::GPUAccelerated2DCanvasSurfaceCreationFailed);
     m_surfaceCreationFailedAtLeastOnce = true;
   }
 }
 
-PaintSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
+SkSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
   if (m_surface)
     return m_surface.get();
 
   if (m_layer && !isHibernating() && hint == PreferAcceleration &&
       m_accelerationMode != DisableAcceleration) {
     return nullptr;  // re-creation will happen through restore()
   }
 
   bool wantAcceleration = shouldAccelerate(hint);
   if (CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU && isHidden() &&
       wantAcceleration) {
     wantAcceleration = false;
     m_softwareRenderingWhileHidden = true;
   }
 
   bool surfaceIsAccelerated;
   m_surface = createSkSurface(
       wantAcceleration ? m_contextProvider->grContext() : nullptr, m_size,
       m_msaaSampleCount, m_opacityMode, skSurfaceColorSpace(), m_colorType,
       &surfaceIsAccelerated);
+  m_surfacePaintCanvas =
+      WTF::wrapUnique(new PaintCanvas(m_surface->getCanvas()));
 
   if (m_surface) {
     // Always save an initial frame, to support resetting the top level matrix
     // and clip.
-    m_surface->getCanvas()->save();
+    m_surfacePaintCanvas->save();
   } else {
     reportSurfaceCreationFailure();
   }
 
   if (m_surface && surfaceIsAccelerated && !m_layer) {
     m_layer =
         Platform::current()->compositorSupport()->createExternalTextureLayer(
             this);
     m_layer->setOpaque(m_opacityMode == Opaque);
     m_layer->setBlendBackgroundColor(m_opacityMode != Opaque);
     GraphicsLayer::registerContentsLayer(m_layer->layer());
     m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
   }
 
   if (m_surface && isHibernating()) {
     if (surfaceIsAccelerated) {
       m_logger->reportHibernationEvent(HibernationEndedNormally);
     } else {
       if (isHidden())
         m_logger->reportHibernationEvent(
             HibernationEndedWithSwitchToBackgroundRendering);
       else
         m_logger->reportHibernationEvent(HibernationEndedWithFallbackToSW);
     }
 
-    PaintFlags copyPaint;
+    SkPaint copyPaint;
     copyPaint.setBlendMode(SkBlendMode::kSrc);
     m_surface->getCanvas()->drawImage(m_hibernationImage.get(), 0, 0,
                                       &copyPaint);
     m_hibernationImage.reset();
 
     if (m_imageBuffer)
       m_imageBuffer->updateGPUMemoryUsage();
 
     if (m_imageBuffer && !m_isDeferralEnabled)
-      m_imageBuffer->resetCanvas(m_surface->getCanvas());
+      m_imageBuffer->resetCanvas(m_surfacePaintCanvas.get());
   }
 
   return m_surface.get();
 }
 
 PaintCanvas* Canvas2DLayerBridge::canvas() {
   if (!m_isDeferralEnabled) {
-    PaintSurface* s = getOrCreateSurface();
-    return s ? s->getCanvas() : nullptr;
+    getOrCreateSurface();
+    return m_surfacePaintCanvas.get();
   }
   return m_recorder->getRecordingCanvas();
 }
 
 void Canvas2DLayerBridge::disableDeferral(DisableDeferralReason reason) {
   // Disabling deferral is permanent: once triggered by disableDeferral()
   // we stay in immediate mode indefinitely. This is a performance heuristic
   // that significantly helps a number of use cases. The rationale is that if
   // immediate rendering was needed once, it is likely to be needed at least
   // once per frame, which eliminates the possibility for inter-frame
@@ skipping 11 matching lines @@
   CanvasMetrics::countCanvasContextUsage(
       CanvasMetrics::GPUAccelerated2DCanvasDeferralDisabled);
   flushRecordingOnly();
   // Because we will be discarding the recorder, if the flush failed
   // content will be lost -> force m_haveRecordedDrawCommands to false
   m_haveRecordedDrawCommands = false;
 
   m_isDeferralEnabled = false;
   m_recorder.reset();
   // install the current matrix/clip stack onto the immediate canvas
-  PaintSurface* surface = getOrCreateSurface();
-  if (m_imageBuffer && surface)
-    m_imageBuffer->resetCanvas(surface->getCanvas());
+  getOrCreateSurface();
+  if (m_imageBuffer && m_surfacePaintCanvas)
+    m_imageBuffer->resetCanvas(m_surfacePaintCanvas.get());
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer) {
   m_imageBuffer = imageBuffer;
   if (m_imageBuffer && m_isDeferralEnabled) {
     m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
   }
 }
 
 void Canvas2DLayerBridge::beginDestruction() {
   if (m_destructionInProgress)
     return;
   if (isHibernating())
     m_logger->reportHibernationEvent(HibernationEndedWithTeardown);
   m_hibernationImage.reset();
   m_recorder.reset();
   m_imageBuffer = nullptr;
   m_destructionInProgress = true;
   setIsHidden(true);
-  m_surface.reset();
+  ResetSurface();
 
   if (m_layer && m_accelerationMode != DisableAcceleration) {
     GraphicsLayer::unregisterContentsLayer(m_layer->layer());
     m_layer->clearTexture();
     // Orphaning the layer is required to trigger the recration of a new layer
     // in the case where destruction is caused by a canvas resize. Test:
     // virtual/gpu/fast/canvas/canvas-resize-after-paint-without-layout.html
     m_layer->layer()->removeFromParent();
   }
 
@@ skipping 24 matching lines @@
           BLINK_FROM_HERE, WTF::bind(&hibernateWrapperForTesting,
                                      m_weakPtrFactory.createWeakPtr()));
     } else {
       Platform::current()->currentThread()->scheduler()->postIdleTask(
           BLINK_FROM_HERE,
           WTF::bind(&hibernateWrapper, m_weakPtrFactory.createWeakPtr()));
     }
   }
   if (!isHidden() && m_softwareRenderingWhileHidden) {
     flushRecordingOnly();
-    PaintFlags copyPaint;
+    SkPaint copyPaint;
     copyPaint.setBlendMode(SkBlendMode::kSrc);
 
-    sk_sp<PaintSurface> oldSurface = std::move(m_surface);
-    m_surface.reset();
+    sk_sp<SkSurface> oldSurface = std::move(m_surface);
+    ResetSurface();
 
     m_softwareRenderingWhileHidden = false;
-    PaintSurface* newSurface =
+    SkSurface* newSurface =
         getOrCreateSurface(PreferAccelerationAfterVisibilityChange);
     if (newSurface) {
       if (oldSurface)
         oldSurface->draw(newSurface->getCanvas(), 0, 0, &copyPaint);
       if (m_imageBuffer && !m_isDeferralEnabled) {
-        m_imageBuffer->resetCanvas(m_surface->getCanvas());
+        m_imageBuffer->resetCanvas(m_surfacePaintCanvas.get());
       }
     }
   }
   if (!isHidden() && isHibernating()) {
     getOrCreateSurface();  // Rude awakening
   }
 }
 
 bool Canvas2DLayerBridge::writePixels(const SkImageInfo& origInfo,
                                       const void* pixels,
@@ skipping 81 matching lines @@
   if (m_destructionInProgress)
     return false;
   if (isHibernating())
     return true;
   if (!m_layer || m_accelerationMode == DisableAcceleration)
     return true;
   if (!m_surface)
     return false;
   if (m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() !=
       GL_NO_ERROR) {
-    m_surface.reset();
+    ResetSurface();
     for (auto mailboxInfo = m_mailboxes.begin();
          mailboxInfo != m_mailboxes.end(); ++mailboxInfo) {
       if (mailboxInfo->m_image)
         mailboxInfo->m_image.reset();
     }
     if (m_imageBuffer)
       m_imageBuffer->notifySurfaceInvalid();
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::Accelerated2DCanvasGPUContextLost);
   }
   return m_surface.get();
 }
 
 bool Canvas2DLayerBridge::restoreSurface() {
   DCHECK(!m_destructionInProgress);
   if (m_destructionInProgress || !isAccelerated())
     return false;
   DCHECK(!m_surface);
 
   gpu::gles2::GLES2Interface* sharedGL = nullptr;
   m_layer->clearTexture();
   m_contextProvider = WTF::wrapUnique(
       Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
   if (m_contextProvider)
     sharedGL = m_contextProvider->contextGL();
 
   if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
     GrContext* grCtx = m_contextProvider->grContext();
     bool surfaceIsAccelerated;
-    sk_sp<PaintSurface> surface(createSkSurface(
+    sk_sp<SkSurface> surface(createSkSurface(
         grCtx, m_size, m_msaaSampleCount, m_opacityMode, skSurfaceColorSpace(),
         m_colorType, &surfaceIsAccelerated));
     if (!m_surface)
       reportSurfaceCreationFailure();
 
     // The current paradigm does not support switching from accelerated to
     // non-accelerated, which would be tricky due to changes to the layer tree,
     // which can only happen at specific times during the document lifecycle.
     // Therefore, we can only accept the restored surface if it is accelerated.
     if (surface && surfaceIsAccelerated) {
@@ skipping 239 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram,
                       ("Canvas.HibernationEvents", HibernationEventCount));
   hibernationHistogram.count(event);
 }
 
 }  // namespace blink