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"
@@ skipping 99 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 ProcessCopyOutputResponse(
+      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 = ProcessCopyOutputResponse(
+      video_frame, start_time, capture_frame_cb, result.Pass());
+
+  base::TimeDelta capture_time = base::TimeTicks::Now() - start_time;
+  UMA_HISTOGRAM_TIMES(
+      window_id_.type == DesktopMediaID::TYPE_SCREEN ? kUmaScreenCaptureTime
+                                                     : kUmaWindowCaptureTime,
+      capture_time);
+
+  if (first_call) {
+    first_call = false;
+    if (window_id_.type == DesktopMediaID::TYPE_SCREEN) {
+      IncrementDesktopCaptureCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED
+                                               : FIRST_SCREEN_CAPTURE_FAILED);
+    } else {
+      IncrementDesktopCaptureCounter(succeeded
+                                         ? FIRST_WINDOW_CAPTURE_SUCCEEDED
+                                         : FIRST_WINDOW_CAPTURE_SUCCEEDED);
+    }
+  }
+}
+
+bool DesktopVideoCaptureMachine::ProcessCopyOutputResponse(
+    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)));
+  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) {
+  IncrementDesktopCaptureCounter(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