Adds UMA histograms for desktop capture device.

content/browser/media/capture/desktop_capture_device_aura.cc

 // Copyright 2013 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/desktop_capture_device_aura.h"
 
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/media/capture/content_video_capture_device_core.h"
+#include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/base/video_util.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursors_aura.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 
 namespace content {
 
 namespace {
 
+void IncrementCounter(DesktopCaptureCounters counter) {
+  UMA_HISTOGRAM_ENUMERATION(kUMADesopCaptureCounters,
+                            counter,
+                            DESKTOP_CAPTURE_COUNTER_BOUNDARY);
+}
+
 int clip_byte(int x) {
   return std::max(0, std::min(x, 255));
 }
 
 int alpha_blend(int alpha, int src, int dst) {
   return (src * alpha + dst * (255 - alpha)) / 255;
 }
 
 // Helper function to composite a cursor bitmap on a YUV420 video frame.
 void RenderCursorOnVideoFrame(
@@ skipping 79 matching lines @@
   // Update capture size. Must be called on the UI thread.
   void UpdateCaptureSize();
 
   // Response callback for cc::Layer::RequestCopyOfOutput().
   void DidCopyOutput(
       scoped_refptr<media::VideoFrame> video_frame,
       base::TimeTicks start_time,
       const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
       scoped_ptr<cc::CopyOutputResult> result);
 
+  // A helper which does the real work for DidCopyOutput. Returns true if
+  // succeeded.
+  bool DidCopyOutputHelper(
+      scoped_refptr<media::VideoFrame> video_frame,
+      base::TimeTicks start_time,
+      const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
+      scoped_ptr<cc::CopyOutputResult> result);
+
   // Helper function to update cursor state.
   // |region_in_frame| defines the desktop bound in the captured frame.
   // Returns the current cursor position in captured frame.
   gfx::Point UpdateCursorState(const gfx::Rect& region_in_frame);
 
   // Clears cursor state.
   void ClearCursorState();
 
   // The window associated with the desktop.
   aura::Window* desktop_window_;
@@ skipping 143 matching lines @@
     RenderCursorOnVideoFrame(target, cursor_bitmap, cursor_position);
   release_callback->Run(0, false);
   capture_frame_cb.Run(start_time, result);
 }
 
 void DesktopVideoCaptureMachine::DidCopyOutput(
     scoped_refptr<media::VideoFrame> video_frame,
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     scoped_ptr<cc::CopyOutputResult> result) {
+  static bool first_call = true;
+
+  bool succeeded = DidCopyOutputHelper(
+      video_frame, start_time, capture_frame_cb, result.Pass());
+
+  if (first_call) {
+    first_call = false;
+    if (window_id_.type == DesktopMediaID::TYPE_SCREEN) {
+      IncrementCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED :
+          FIRST_SCREEN_CAPTURE_FAILED);

[Sergey Ulanov, 2014/04/24 19:33:24]

nit: indentation. Also : can be wrapped. clang-format formats this code as
follows:

  IncrementCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED
                             : FIRST_SCREEN_CAPTURE_FAILED);

[jiayl, 2014/04/24 20:58:55]

Done.

+    } else {
+      IncrementCounter(succeeded ? FIRST_WINDOW_CAPTURE_SUCCEEDED :
+          FIRST_WINDOW_CAPTURE_SUCCEEDED);
+    }
+  }
+}
+
+bool DesktopVideoCaptureMachine::DidCopyOutputHelper(

[Sergey Ulanov, 2014/04/24 19:33:24]

Call this something like ProcessCopyOutputResponse()

[jiayl, 2014/04/24 20:58:55]

Done.

+    scoped_refptr<media::VideoFrame> video_frame,
+    base::TimeTicks start_time,
+    const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
+    scoped_ptr<cc::CopyOutputResult> result) {
   if (result->IsEmpty() || result->size().IsEmpty() || !desktop_layer_)
-    return;
+    return false;
 
   // Compute the dest size we want after the letterboxing resize. Make the
   // coordinates and sizes even because we letterbox in YUV space
   // (see CopyRGBToVideoFrame). They need to be even for the UV samples to
   // line up correctly.
   // The video frame's coded_size() and the result's size() are both physical
   // pixels.
   gfx::Rect region_in_frame =
       media::ComputeLetterboxRegion(gfx::Rect(video_frame->coded_size()),
                                     result->size());
   region_in_frame = gfx::Rect(region_in_frame.x() & ~1,
                               region_in_frame.y() & ~1,
                               region_in_frame.width() & ~1,
                               region_in_frame.height() & ~1);
   if (region_in_frame.IsEmpty())
-    return;
+    return false;
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   GLHelper* gl_helper = factory->GetGLHelper();
   if (!gl_helper)
-    return;
+    return false;
 
   cc::TextureMailbox texture_mailbox;
   scoped_ptr<cc::SingleReleaseCallback> release_callback;
   result->TakeTexture(&texture_mailbox, &release_callback);
   DCHECK(texture_mailbox.IsTexture());
   if (!texture_mailbox.IsTexture())
-    return;
+    return false;
 
   gfx::Rect result_rect(result->size());
   if (!yuv_readback_pipeline_ ||
       yuv_readback_pipeline_->scaler()->SrcSize() != result_rect.size() ||
       yuv_readback_pipeline_->scaler()->SrcSubrect() != result_rect ||
       yuv_readback_pipeline_->scaler()->DstSize() != region_in_frame.size()) {
     yuv_readback_pipeline_.reset(
         gl_helper->CreateReadbackPipelineYUV(GLHelper::SCALER_QUALITY_FAST,
                                              result_rect.size(),
                                              result_rect,
                                              video_frame->coded_size(),
                                              region_in_frame,
                                              true,
                                              true));
   }
 
   gfx::Point cursor_position_in_frame = UpdateCursorState(region_in_frame);
   yuv_readback_pipeline_->ReadbackYUV(
       texture_mailbox.mailbox(),
       texture_mailbox.sync_point(),
       video_frame.get(),
       base::Bind(&CopyOutputFinishedForVideo,
                  start_time,
                  capture_frame_cb,
                  video_frame,
                  scaled_cursor_bitmap_,
                  cursor_position_in_frame,
                  base::Passed(&release_callback)));
+
+  base::TimeDelta capture_time = base::TimeTicks::Now() - start_time;

[Sergey Ulanov, 2014/04/24 19:33:24]

Move this to DidCopyOutput() so that all UMA logic is in one place?

[jiayl, 2014/04/24 20:58:55]

Done.

+  if (window_id_.type == DesktopMediaID::TYPE_SCREEN)
+    UMA_HISTOGRAM_TIMES(kUMAScreenCaptureTime, capture_time);

[Sergey Ulanov, 2014/04/24 19:33:24]

{}

[jiayl, 2014/04/24 20:58:55]

It's not required for single line conditionals.

+  else
+    UMA_HISTOGRAM_TIMES(kUMAWindowCaptureTime, capture_time);
+
+  return true;
 }
 
 gfx::Point DesktopVideoCaptureMachine::UpdateCursorState(
     const gfx::Rect& region_in_frame) {
   const gfx::Rect desktop_bounds = desktop_layer_->bounds();
   gfx::NativeCursor cursor =
       desktop_window_->GetHost()->last_cursor();
   if (last_cursor_ != cursor) {
     SkBitmap cursor_bitmap;
     if (ui::GetCursorBitmap(cursor, &cursor_bitmap, &cursor_hot_point_)) {
@@ skipping 62 matching lines @@
     : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>(
         new DesktopVideoCaptureMachine(source)))) {}
 
 DesktopCaptureDeviceAura::~DesktopCaptureDeviceAura() {
   DVLOG(2) << "DesktopCaptureDeviceAura@" << this << " destroying.";
 }
 
 // static
 media::VideoCaptureDevice* DesktopCaptureDeviceAura::Create(
     const DesktopMediaID& source) {
+  IncrementCounter(source.type == DesktopMediaID::TYPE_SCREEN ?
+      SCREEN_CAPTURER_CREATED : WINDOW_CATPTURER_CREATED);
   return new DesktopCaptureDeviceAura(source);
 }
 
 void DesktopCaptureDeviceAura::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   core_->AllocateAndStart(params, client.Pass());
 }
 
 void DesktopCaptureDeviceAura::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content