Use proper tracing category in image/tab capture trace logs

content/browser/media/capture/content_video_capture_device_core.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 "content/browser/media/capture/content_video_capture_device_core.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/callback_helpers.h"
@@ skipping 72 matching lines @@
       client_->ReserveOutputBuffer(video_frame_format, coded_size);
   const bool should_capture =
       oracle_.ObserveEventAndDecideCapture(event, damage_rect, event_time);
   const char* event_name =
       (event == VideoCaptureOracle::kTimerPoll ? "poll" :
        (event == VideoCaptureOracle::kCompositorUpdate ? "gpu" :
        "paint"));
 
   // Consider the various reasons not to initiate a capture.
   if (should_capture && !output_buffer.get()) {
-    TRACE_EVENT_INSTANT1("mirroring",
+    TRACE_EVENT_INSTANT1("gpu.capture",
                          "PipelineLimited",
                          TRACE_EVENT_SCOPE_THREAD,
                          "trigger",
                          event_name);
     return false;
   } else if (!should_capture && output_buffer.get()) {
     if (event == VideoCaptureOracle::kCompositorUpdate) {
       // 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_INSTANT1("gpu.capture", "FpsRateLimited",
                            TRACE_EVENT_SCOPE_THREAD,
                            "trigger", event_name);
     }
     return false;
   } else if (!should_capture && !output_buffer.get()) {
     // 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", "NearlyPipelineLimited",
+    TRACE_EVENT_INSTANT1("gpu.capture", "NearlyPipelineLimited",
                          TRACE_EVENT_SCOPE_THREAD,
                          "trigger", event_name);
     return false;
   }
   int frame_number = oracle_.RecordCapture();
-  TRACE_EVENT_ASYNC_BEGIN2("mirroring", "Capture", output_buffer.get(),
+  TRACE_EVENT_ASYNC_BEGIN2("gpu.capture", "Capture", output_buffer.get(),
                            "frame_number", frame_number,
                            "trigger", event_name);
   // NATIVE_TEXTURE frames wrap a texture mailbox, which we don't have at the
   // moment.  We do not construct those frames.
   if (video_frame_format != media::VideoFrame::NATIVE_TEXTURE) {
     *storage = media::VideoFrame::WrapExternalPackedMemory(
         video_frame_format,
         coded_size,
         gfx::Rect(visible_size),
         visible_size,
@@ skipping 53 matching lines @@
 }
 
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     int frame_number,
     const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer,
     base::TimeTicks capture_begin_time,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp,
     bool success) {
   base::AutoLock guard(lock_);
-  TRACE_EVENT_ASYNC_END2("mirroring", "Capture", buffer.get(),
+  TRACE_EVENT_ASYNC_END2("gpu.capture", "Capture", buffer.get(),
                          "success", success,
                          "timestamp", timestamp.ToInternalValue());
 
   if (!client_)
     return;  // Capture is stopped.
 
   if (success) {
     if (oracle_.CompleteCapture(frame_number, &timestamp)) {
       // TODO(miu): Use the locked-in frame rate from AnimatedContentSampler.
       frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
@@ skipping 138 matching lines @@
     return;
 
   if (oracle_proxy_.get())
     oracle_proxy_->ReportError(reason);
 
   StopAndDeAllocate();
   TransitionStateTo(kError);
 }
 
 }  // namespace content