Add a |scope| argument to TRACE_EVENT_INSTANT* and require its presence.

content/browser/renderer_host/media/web_contents_video_capture_device.cc

 // Copyright (c) 2012 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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the consumer's
@@ skipping 438 matching lines @@
     should_sample = sampler_.IsOverdueForSamplingAt(now);
   }
 
   const char* event_name = (event == TIMER_POLL ? "poll" :
                             (event == COMPOSITOR_UPDATE ? "gpu" :
                              "paint"));
 
   // Step 3: Consider the various reasons not to initiate a capture.
   if (should_sample && !output_buffer) {
     TRACE_EVENT_INSTANT1("mirroring", "EncodeLimited",
+                         TRACE_EVENT_SCOPE_THREAD,
                          "trigger", event_name);
     return false;
   } else if (!should_sample && output_buffer) {
     if (content_is_dirty) {
       // This is a normal and acceptable way to drop a frame. We've hit our
       // capture rate limit: for example, the content is animating at 60fps but
       // we're capturing at 30fps.
       TRACE_EVENT_INSTANT1("mirroring", "FpsRateLimited",
+                           TRACE_EVENT_SCOPE_THREAD,
                            "trigger", event_name);
     }
     return false;
   } else if (!should_sample && !output_buffer) {
     // We decided not to capture, but we wouldn't have been able to if we wanted
     // to because no output buffer was available.
     TRACE_EVENT_INSTANT1("mirroring", "NearlyEncodeLimited",
+                         TRACE_EVENT_SCOPE_THREAD,
                          "trigger", event_name);
     return false;
   }
 
   // Step 4: Initiate a capture.
   sampler_.RecordSample();
   TRACE_EVENT_ASYNC_BEGIN2("mirroring", "Capture", output_buffer.get(),
                            "frame_number", frame_number_,
                            "trigger", event_name);
   *storage = output_buffer;
@@ skipping 14 matching lines @@
 
 void CaptureOracle::ReportError() {
   base::AutoLock guard(lock_);
   if (consumer_)
     consumer_->OnError();
 }
 
 void CaptureOracle::InvalidateConsumer() {
   base::AutoLock guard(lock_);
 
-  TRACE_EVENT_INSTANT0("mirroring", "InvalidateConsumer");
+  TRACE_EVENT_INSTANT0("mirroring", "InvalidateConsumer",
+                       TRACE_EVENT_SCOPE_THREAD);
 
   is_started_ = false;
   consumer_ = NULL;
 }
 
 void CaptureOracle::DidCaptureFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     base::Time timestamp,
     bool success) {
   base::AutoLock guard(lock_);
@@ skipping 784 matching lines @@
     return false;
   else
     return true;
 }
 
 base::Time SmoothEventSampler::GetLastSampledEvent() {
   return last_sample_;
 }
 
 }  // namespace content