Adding some nullptr checks around calls to Canvas2DLayerBridge::getOrCreateSurface

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 306 matching lines @@
     // required multiple times per frame, the repeated flushing of deferred
     // commands would cause significant overhead, so it is better to just stop
     // trying to defer altogether.
     if (!m_isDeferralEnabled)
         return;
 
     m_isDeferralEnabled = false;
     flushRecordingOnly();
     m_recorder.clear();
     // install the current matrix/clip stack onto the immediate canvas
-    if (m_imageBuffer)
-        m_imageBuffer->resetCanvas(getOrCreateSurface()->getCanvas());
+    SkSurface* surface = getOrCreateSurface();
+    if (m_imageBuffer && surface)
+        m_imageBuffer->resetCanvas(surface->getCanvas());
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer)
 {
     m_imageBuffer = imageBuffer;
     if (m_imageBuffer && m_isDeferralEnabled) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
 }
 
@@ skipping 180 matching lines @@
     if (m_contextProvider)
         sharedContext = m_contextProvider->context3d();
 
     if (sharedContext && !sharedContext->isContextLost()) {
         GrContext* grCtx = m_contextProvider->grContext();
         bool surfaceIsAccelerated;
         RefPtr<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated));
         // Current paradigm does 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.get() && surfaceIsAccelerated) {
+        if (surface && surfaceIsAccelerated) {
             m_surface = surface.release();
             // FIXME: draw sad canvas picture into new buffer crbug.com/243842
         }
     }
     if (m_imageBuffer)
         m_imageBuffer->updateGPUMemoryUsage();
 
     return m_surface;
 }
 
@@ skipping 16 matching lines @@
 
     if (bitmap) {
         // Using accelerated 2d canvas with software renderer, which
         // should only happen in tests that use fake graphics contexts
         // or in Android WebView in software mode. In this case, we do
         // not care about producing any results for this canvas.
         skipQueuedDrawCommands();
         m_lastImageId = 0;
         return false;
     }
-    if (!checkSurfaceValid())

[Justin Novosad, 2015/12/15 18:55:55]

This check is expensive and was redundant with the same check being done in
newImageSnapshot()

+
+    RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration);
+    if (!image)
         return false;
 
     WebGraphicsContext3D* webContext = context();
 
-    RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration);
-
     // Early exit if canvas was not drawn to since last prepareMailbox
     GLenum filter = m_filterQuality == kNone_SkFilterQuality ? GL_NEAREST : GL_LINEAR;
     if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
         return false;
     m_lastImageId = image->uniqueID();
     m_lastFilter = filter;
 
     {
         MailboxInfo tmp;
         tmp.m_image = image;
@@ skipping 172 matching lines @@
 
 void Canvas2DLayerBridge::willProcessTask()
 {
     ASSERT_NOT_REACHED();
 }
 
 PassRefPtr<SkImage> Canvas2DLayerBridge::newImageSnapshot(AccelerationHint hint)
 {
     if (!checkSurfaceValid())
         return nullptr;
-    getOrCreateSurface(hint);
+    if (!getOrCreateSurface(hint))
+        return nullptr;
     flush();
     // A readback operation may alter the texture parameters, which may affect
     // the compositor's behavior. Therefore, we must trigger copy-on-write
     // even though we are not technically writing to the texture, only to its
     // parameters.
     getOrCreateSurface()->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
     return adoptRef(m_surface->newImageSnapshot());
 }
 
 void Canvas2DLayerBridge::willOverwriteCanvas()
 {
     skipQueuedDrawCommands();
 }
 
 Canvas2DLayerBridge::MailboxInfo::MailboxInfo(const MailboxInfo& other)
 {
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     m_image = other.m_image;
     m_parentLayerBridge = other.m_parentLayerBridge;
 }
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     blink::Platform::current()->histogramEnumeration("Canvas.HibernationEvents", event, HibernationEventCount);
 }
 
 } // namespace blink