Add trace events corresponding to OffscreenCanvas overhead

third_party/WebKit/Source/core/offscreencanvas/OffscreenCanvas.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/offscreencanvas/OffscreenCanvas.h"
 
 #include <memory>
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/CanvasAsyncBlobCreator.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/html/canvas/CanvasRenderingContextFactory.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/image-encoders/ImageEncoderUtils.h"
+#include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/wtf/MathExtras.h"
 #include "public/platform/Platform.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace blink {
 
 OffscreenCanvas::OffscreenCanvas(const IntSize& size) : size_(size) {}
 
 OffscreenCanvas* OffscreenCanvas::Create(unsigned width, unsigned height) {
   return new OffscreenCanvas(
@@ skipping 201 matching lines @@
         this, client_id_, sink_id_, placeholder_canvas_id_, size_.Width(),
         size_.Height()));
   }
   return frame_dispatcher_.get();
 }
 
 ScriptPromise OffscreenCanvas::Commit(RefPtr<StaticBitmapImage> image,
                                       bool is_web_gl_software_rendering,
                                       ScriptState* script_state,
                                       ExceptionState& exception_state) {
+  TRACE_EVENT0("blink", "OffscreenCanvas::Commit");
+
   if (!HasPlaceholderCanvas()) {
     exception_state.ThrowDOMException(
         kInvalidStateError,
         "Commit() was called on a context whose "
         "OffscreenCanvas is not associated with a "
         "canvas element.");
     return exception_state.Reject(script_state);
   }
 
   GetOrCreateFrameDispatcher()->SetNeedsBeginFrame(true);
@@ skipping 26 matching lines @@
   if (current_frame_) {
     // TODO(eseckler): OffscreenCanvas shouldn't dispatch CompositorFrames
     // without a prior BeginFrame.
     DoCommit(std::move(current_frame_),
              current_frame_is_web_gl_software_rendering_);
   }
 }
 
 void OffscreenCanvas::DoCommit(RefPtr<StaticBitmapImage> image,
                                bool is_web_gl_software_rendering) {
+  TRACE_EVENT0("blink", "OffscreenCanvas::DoCommit");
   double commit_start_time = WTF::MonotonicallyIncreasingTime();
   GetOrCreateFrameDispatcher()->DispatchFrame(
       std::move(image), commit_start_time, is_web_gl_software_rendering);
 }
 
 void OffscreenCanvas::BeginFrame() {
+  TRACE_EVENT0("blink", "OffscreenCanvas::BeginFrame");
   if (current_frame_) {
     // TODO(eseckler): beginFrame() shouldn't be used as confirmation of
     // CompositorFrame activation.
     // If we have an overdraw backlog, push the frame from the backlog
     // first and save the promise resolution for later.
     // Then we need to wait for one more frame time to resolve the existing
     // promise.
     DoCommit(std::move(current_frame_),
              current_frame_is_web_gl_software_rendering_);
   } else if (commit_promise_resolver_) {
     commit_promise_resolver_->Resolve();
     commit_promise_resolver_.Clear();
+
     // We need to tell parent frame to stop sending signals on begin frame to
     // avoid overhead once we resolve the promise.
     GetOrCreateFrameDispatcher()->SetNeedsBeginFrame(false);
   }
 }
 
 ScriptPromise OffscreenCanvas::convertToBlob(ScriptState* script_state,
                                              const ImageEncodeOptions& options,
                                              ExceptionState& exception_state) {
   if (this->IsNeutered()) {
@@ skipping 45 matching lines @@
 }
 
 DEFINE_TRACE(OffscreenCanvas) {
   visitor->Trace(context_);
   visitor->Trace(execution_context_);
   visitor->Trace(commit_promise_resolver_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
 }  // namespace blink