DevTools: add instrumentation for deferred canvas rasterization

Source/core/platform/graphics/chromium/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 12 matching lines @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/platform/graphics/chromium/Canvas2DLayerBridge.h"
 
 #include "GrContext.h"
 #include "SkDevice.h"
 #include "SkSurface.h"
+#include "core/platform/PlatformInstrumentation.h"
 #include "core/platform/chromium/TraceEvent.h"
 #include "core/platform/graphics/GraphicsContext3D.h"
 #include "core/platform/graphics/GraphicsLayer.h"
 #include "core/platform/graphics/chromium/Canvas2DLayerManager.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebGraphicsContext3D.h"
 
 using WebKit::WebExternalTextureLayer;
 using WebKit::WebGraphicsContext3D;
@@ skipping 144 matching lines @@
             // Invalidate texture state in case the compositor altered it since the copy-on-write.
             mailboxInfo->m_image->getTexture()->invalidateCachedState();
             mailboxInfo->m_image.reset(0);
             mailboxInfo->m_status = MailboxAvailable;
         }
     }
     SkAutoTUnref<SkImage> image(m_canvas->newImageSnapshot());
     // Early exit if canvas was not drawn to since last prepareMailbox
     if (image->uniqueID() == m_lastImageId)
         return false;
+    PlatformInstrumentation::willRasterizeCanvas();

[Justin Novosad, 2013/06/26 21:06:49]

This will only measure deferred canvas rendering in the context of a layer
update.  There are other circumstance where deferred canvas rendering can get
triggered (Deferal buffer is full, JS command that triggers a synchronous
readback, canvas-to-canvas copy using drawImage).  If we are only concerned with
filling the gap in the timeline, then this is OK.  However if we want to
accurately report time spent executing deferred canvas draw operations, we
should be calling willRasterizeCanvas in prepareForDraw, and we should call
didRasterizeCanvas in flushedDrawCommands.  Also, if we do that, we<d have to
change the implementation of skippedPendingDrawCommands so that it no longer
calls flushedDrawCommands, because we don't want it to call didRasterizeCanvas.

[caseq, 2013/06/27 17:03:50]

Thanks, Justin, it's very helpful! I was originally aiming at instrumenting just
the part that the main thread was being blocked on a sync gl call, since we
don't yet have a good way to show async stuff that happens on GPU -- so it
basically only worked to fill the timeline gap. Turns out the fact that we were
doing the sync call here was a bug on its own (fixed by piman at r152657), so my
original approach is no longer relevant here (we just block elsewhere). So it
looks like we need properly expose it as an async/background event for canvas
flush, which will likely require a bit more work on the timeline side.

     m_lastImageId = image->uniqueID();
 
     mailboxInfo = createMailboxInfo();
     mailboxInfo->m_status = MailboxInUse;
     mailboxInfo->m_image.swap(&image);
     // Because of texture sharing with the compositor, we must invalidate
     // the state cached in skia so that the deferred copy on write
     // in SkSurface_Gpu does not make any false assumptions.
     mailboxInfo->m_image->getTexture()->invalidateCachedState();
 
@@ skipping 10 matching lines @@
     context()->flush();
     mailboxInfo->m_mailbox.syncPoint = context()->insertSyncPoint();
     m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);
     // Because we are changing the texture binding without going through skia,
     // we must dirty the context.
     // TODO(piman): expose finer granularity reset. We only really want to
     // 'dirty' the current texture binding.
     m_context->grContext()->resetContext();
 
     *outMailbox = mailboxInfo->m_mailbox;
+    PlatformInstrumentation::didRasterizeCanvas();
     return true;
 #else
     ASSERT_NOT_REACHED();
     return false;
 #endif
 }
 
 #if ENABLE(CANVAS_USES_MAILBOX)
 Canvas2DLayerBridge::MailboxInfo* Canvas2DLayerBridge::createMailboxInfo() {
     MailboxInfo* mailboxInfo;
@@ skipping 63 matching lines @@
     // This copy constructor should only be used for Vector reallocation
     // Assuming 'other' is to be destroyed, we swap m_image ownership
     // rather than do a refcount dance.
     memcpy(&m_mailbox, &other.m_mailbox, sizeof(m_mailbox));
     m_image.swap(const_cast<SkAutoTUnref<SkImage>*>(&other.m_image));
     m_status = other.m_status;
 }
 #endif
 
 }