Adds UMA histograms for desktop capture device.

content/browser/media/capture/desktop_capture_device.cc

Index: content/browser/media/capture/desktop_capture_device.cc
diff --git a/content/browser/media/capture/desktop_capture_device.cc b/content/browser/media/capture/desktop_capture_device.cc
index bcd0dbb8bf95c8ac6a4410d8f1dafd77e95b730c..7d5915c0feb430a9293d6cfa20003db0371c675b 100644
--- a/content/browser/media/capture/desktop_capture_device.cc
+++ b/content/browser/media/capture/desktop_capture_device.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
@@ -27,6 +28,22 @@ namespace content {
 
 namespace {
 
+enum DesktopCaptureCounters {
+  SCREEN_CAPTURER_CREATED,
+  WINDOW_CATPTURER_CREATED,
+  FIRST_SCREEN_CAPTURE_SUCCEEDED,
+  FIRST_SCREEN_CAPTURE_FAILED,
+  FIRST_WINDOW_CAPTURE_SUCCEEDED,
+  FIRST_WINDOW_CAPTURE_FAILED,
+  DESKTOP_CAPTURE_COUNTER_BOUNDARY

[Ilya Sherman, 2014/04/24 01:57:43]

nit: Please document that since this enum is used to back an UMA histogram, it
should be treated as append-only.

+};
+
+void IncrementCounter(DesktopCaptureCounters counter) {
+  UMA_HISTOGRAM_ENUMERATION("WebRTC.DesktopCaptureCounters",
+                            counter,
+                            DESKTOP_CAPTURE_COUNTER_BOUNDARY);
+}
+
 // Maximum CPU time percentage of a single core that can be consumed for desktop
 // capturing. This means that on systems where screen scraping is slow we may
 // need to capture at frame rate lower than requested. This is necessary to keep
@@ -50,7 +67,8 @@ class DesktopCaptureDevice::Core
       public webrtc::DesktopCapturer::Callback {
  public:
   Core(scoped_refptr<base::SequencedTaskRunner> task_runner,
-       scoped_ptr<webrtc::DesktopCapturer> capturer);
+       scoped_ptr<webrtc::DesktopCapturer> capturer,
+       DesktopMediaID::Type type);
 
   // Implementation of VideoCaptureDevice methods.
   void AllocateAndStart(const media::VideoCaptureParams& params,
@@ -125,16 +143,21 @@ class DesktopCaptureDevice::Core
   // True when waiting for |desktop_capturer_| to capture current frame.
   bool capture_in_progress_;
 
+  // The type of the capturer.
+  DesktopMediaID::Type capturer_type_;
+
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 DesktopCaptureDevice::Core::Core(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
-    scoped_ptr<webrtc::DesktopCapturer> capturer)
+    scoped_ptr<webrtc::DesktopCapturer> capturer,
+    DesktopMediaID::Type type)
     : task_runner_(task_runner),
       desktop_capturer_(capturer.Pass()),
       capture_task_posted_(false),
-      capture_in_progress_(false) {}
+      capture_in_progress_(false),
+      capturer_type_(type) {}
 
 DesktopCaptureDevice::Core::~Core() {
 }
@@ -172,6 +195,22 @@ void DesktopCaptureDevice::Core::OnCaptureCompleted(
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(capture_in_progress_);
 
+  static bool first_call = true;
+  if (first_call) {
+    first_call = false;
+    if (frame) {
+      if (capturer_type_ == DesktopMediaID::TYPE_SCREEN)

[Sergey Ulanov, 2014/04/24 02:21:20]

maybe use :? to make this code shorter:

if (capturer_type_ == DesktopMediaID::TYPE_SCREEN) {
  IncrementCounter(frame ? FIRST_SCREEN_CAPTURE_SUCCEEDED :
                           FIRST_SCREEN_CAPTURE_FAILED);
} else {
  ...
}

+        IncrementCounter(FIRST_SCREEN_CAPTURE_SUCCEEDED);

[Sergey Ulanov, 2014/04/24 02:21:20]

add {} please

+      else
+        IncrementCounter(FIRST_WINDOW_CAPTURE_SUCCEEDED);
+    } else {
+      if (capturer_type_ == DesktopMediaID::TYPE_SCREEN)
+        IncrementCounter(FIRST_SCREEN_CAPTURE_FAILED);
+      else
+        IncrementCounter(FIRST_WINDOW_CAPTURE_FAILED);
+    }
+  }
+
   capture_in_progress_ = false;
 
   if (!frame) {
@@ -184,6 +223,13 @@ void DesktopCaptureDevice::Core::OnCaptureCompleted(
   if (!client_)
     return;
 
+  base::TimeDelta capture_time(
+      base::TimeDelta::FromMilliseconds(frame->capture_time_ms()));
+  if (capturer_type_ == DesktopMediaID::TYPE_SCREEN)
+    HISTOGRAM_TIMES("WebRTC.ScreenCaptureTime", capture_time);

[Sergey Ulanov, 2014/04/24 02:21:20]

add {} please 

+  else
+    HISTOGRAM_TIMES("WebRTC.WindowCaptureTime", capture_time);

[Ilya Sherman, 2014/04/24 01:57:43]

These should both be UMA_HISTOGRAM_TIMES rather than HISTOGRAM_TIMES.

+
   scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
 
   // Handle initial frame size and size changes.
@@ -389,6 +435,7 @@ scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
         capturer.reset(new webrtc::DesktopAndCursorComposer(
             screen_capturer.release(),
             webrtc::MouseCursorMonitor::CreateForScreen(options, source.id)));
+        IncrementCounter(SCREEN_CAPTURER_CREATED);
       }
       break;
     }
@@ -401,6 +448,7 @@ scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
         capturer.reset(new webrtc::DesktopAndCursorComposer(
             window_capturer.release(),
             webrtc::MouseCursorMonitor::CreateForWindow(options, source.id)));
+        IncrementCounter(WINDOW_CATPTURER_CREATED);
       }
       break;
     }
@@ -411,16 +459,19 @@ scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
   }
 
   scoped_ptr<media::VideoCaptureDevice> result;
-  if (capturer)
-    result.reset(new DesktopCaptureDevice(task_runner, capturer.Pass()));
+  if (capturer) {
+    result.reset(
+        new DesktopCaptureDevice(task_runner, capturer.Pass(), source.type));
+  }
 
   return result.Pass();
 }
 
 DesktopCaptureDevice::DesktopCaptureDevice(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
-    scoped_ptr<webrtc::DesktopCapturer> capturer)
-    : core_(new Core(task_runner, capturer.Pass())) {}
+    scoped_ptr<webrtc::DesktopCapturer> capturer,
+    DesktopMediaID::Type type)
+    : core_(new Core(task_runner, capturer.Pass(), type)) {}
 
 DesktopCaptureDevice::~DesktopCaptureDevice() {
   StopAndDeAllocate();