Add tracing AutoOpenCloseEvent.

media/blink/video_frame_compositor.cc

 // Copyright 2014 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 "media/blink/video_frame_compositor.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/default_tick_clock.h"
+#include "base/trace_event/auto_open_close_event.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 // Amount of time to wait between UpdateCurrentFrame() callbacks before starting
 // background rendering to keep the Render() callbacks moving.
 const int kBackgroundRenderingTimeoutMs = 250;
 
 VideoFrameCompositor::VideoFrameCompositor(
     const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner)
     : compositor_task_runner_(compositor_task_runner),
       tick_clock_(new base::DefaultTickClock()),
       background_rendering_enabled_(true),
       background_rendering_timer_(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kBackgroundRenderingTimeoutMs),
           base::Bind(&VideoFrameCompositor::BackgroundRender,
                      base::Unretained(this)),
           // Task is not repeating, CallRender() will reset the task as needed.
           false),
       client_(nullptr),
       rendering_(false),
       rendered_last_frame_(false),
       is_background_rendering_(false),
       new_background_frame_(false),
       // Assume 60Hz before the first UpdateCurrentFrame() call.
       last_interval_(base::TimeDelta::FromSecondsD(1.0 / 60)),
-      callback_(nullptr) {
+      callback_(nullptr),
+      auto_open_close_(nullptr) {
   background_rendering_timer_.SetTaskRunner(compositor_task_runner_);
+  constructor_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  auto_open_close_ = new base::trace_event::AutoOpenCloseEvent(

[Primiano Tucci (use gerrit), 2016/10/12 16:36:50]

raw pointers with manual new/delete are discouraged. Why this isn't a
scoped_ptr?

[alexandermont, 2016/10/13 19:15:53]

Changed to unique ptr

+      base::trace_event::AutoOpenCloseEvent::Type::ASYNC, "media,rail",
+      "VideoPlayback");
 }
 
 VideoFrameCompositor::~VideoFrameCompositor() {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   DCHECK(!callback_);
   DCHECK(!rendering_);
+  if (auto_open_close_)
+    delete auto_open_close_;

[benjhayden, 2016/10/12 03:05:54]

This will only work if VFC is created on the compositor_task_runner thread.

[Primiano Tucci (use gerrit), 2016/10/12 16:36:50]

this should be just a auto_open_close.reset()

   if (client_)
     client_->StopUsingProvider();
 }
 
 void VideoFrameCompositor::OnRendererStateUpdate(bool new_state) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(rendering_, new_state);
   rendering_ = new_state;
 

[benjhayden, 2016/10/12 20:41:10]

if aoce doesn't exist, aoce_ = new AOCE();
if rendering_: Begin()
else End()

   if (rendering_) {
     // Always start playback in background rendering mode, if |client_| kicks
     // in right away it's okay.
     BackgroundRender();
   } else if (background_rendering_enabled_) {
     background_rendering_timer_.Stop();
   } else {
     DCHECK(!background_rendering_timer_.IsRunning());
   }
 
@@ skipping 33 matching lines @@
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   return CallRender(deadline_min, deadline_max, false);
 }
 
 bool VideoFrameCompositor::HasCurrentFrame() {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   return static_cast<bool>(current_frame_);
 }
 
 void VideoFrameCompositor::Start(RenderCallback* callback) {
-  TRACE_EVENT_ASYNC_BEGIN0("media,rail", "VideoPlayback",
-                           static_cast<const void*>(this));
+  constructor_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&base::trace_event::AutoOpenCloseEvent::Begin,
+                            base::Unretained(auto_open_close_)));
 
   // Called from the media thread, so acquire the callback under lock before
   // returning in case a Stop() call comes in before the PostTask is processed.
   base::AutoLock lock(callback_lock_);
   DCHECK(!callback_);
   callback_ = callback;
   compositor_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate,
                             base::Unretained(this), true));
 }
 
 void VideoFrameCompositor::Stop() {
-  TRACE_EVENT_ASYNC_END0("media,rail", "VideoPlayback",
-                         static_cast<const void*>(this));
+  constructor_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&base::trace_event::AutoOpenCloseEvent::End,
+                            base::Unretained(auto_open_close_)));
 
   // Called from the media thread, so release the callback under lock before
   // returning to avoid a pending UpdateCurrentFrame() call occurring before
   // the PostTask is processed.
   base::AutoLock lock(callback_lock_);
   DCHECK(callback_);
   callback_ = nullptr;
   compositor_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate,
                             base::Unretained(this), false));
@@ skipping 107 matching lines @@
   last_interval_ = deadline_max - deadline_min;
 
   // Restart the background rendering timer whether we're background rendering
   // or not; in either case we should wait for |kBackgroundRenderingTimeoutMs|.
   if (background_rendering_enabled_)
     background_rendering_timer_.Reset();
   return new_frame || had_new_background_frame;
 }
 
 }  // namespace media