Adds UMA histograms for desktop capture device.

content/browser/media/capture/desktop_capture_device.cc

 // Copyright (c) 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.h"
 
 #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"
 #include "base/threading/sequenced_worker_pool.h"
+#include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "media/base/video_util.h"
 #include "third_party/libyuv/include/libyuv/scale_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/window_capturer.h"
 
 namespace content {
 
 namespace {
 
+void IncrementCounter(DesktopCaptureCounters counter) {
+  UMA_HISTOGRAM_ENUMERATION(kUMADesopCaptureCounters,
+                            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
 // UI responsive.
 const int kMaximumCpuConsumptionPercentage = 50;
 
 webrtc::DesktopRect ComputeLetterboxRect(
     const webrtc::DesktopSize& max_size,
     const webrtc::DesktopSize& source_size) {
   gfx::Rect result = media::ComputeLetterboxRegion(
       gfx::Rect(0, 0, max_size.width(), max_size.height()),
       gfx::Size(source_size.width(), source_size.height()));
   return webrtc::DesktopRect::MakeLTRB(
       result.x(), result.y(), result.right(), result.bottom());
 }
 
 }  // namespace
 
 class DesktopCaptureDevice::Core
     : public base::RefCountedThreadSafe<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,
                         scoped_ptr<Client> client);
   void StopAndDeAllocate();
 
   void SetNotificationWindowId(gfx::NativeViewId window_id);
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
@@ skipping 54 matching lines @@
   // and/or letterboxed.
   webrtc::DesktopRect output_rect_;
 
   // True when we have delayed OnCaptureTimer() task posted on
   // |task_runner_|.
   bool capture_task_posted_;
 
   // 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() {
 }
 
 void DesktopCaptureDevice::Core::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
   DCHECK_GT(params.requested_format.frame_rate, 0);
 
@@ skipping 17 matching lines @@
 webrtc::SharedMemory*
 DesktopCaptureDevice::Core::CreateSharedMemory(size_t size) {
   return NULL;
 }
 
 void DesktopCaptureDevice::Core::OnCaptureCompleted(
     webrtc::DesktopFrame* frame) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(capture_in_progress_);
 
+  static bool first_call = true;
+  if (first_call) {
+    first_call = false;
+    if (capturer_type_ == DesktopMediaID::TYPE_SCREEN) {
+      IncrementCounter(frame ?
+          FIRST_SCREEN_CAPTURE_SUCCEEDED : FIRST_SCREEN_CAPTURE_FAILED);
+    } else {
+      IncrementCounter(frame ?
+          FIRST_WINDOW_CAPTURE_SUCCEEDED : FIRST_WINDOW_CAPTURE_FAILED);
+    }
+  }
+
   capture_in_progress_ = false;
 
   if (!frame) {
     std::string log("Failed to capture a frame.");
     LOG(ERROR) << log;
     client_->OnError(log);
     return;
   }
 
   if (!client_)
     return;
 
+  base::TimeDelta capture_time(
+      base::TimeDelta::FromMilliseconds(frame->capture_time_ms()));
+  if (capturer_type_ == DesktopMediaID::TYPE_SCREEN)
+    UMA_HISTOGRAM_TIMES(kUMAScreenCaptureTime, capture_time);

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

add {}

[jiayl, 2014/04/24 20:39:03]

That's not required for single line conditionals:
https://engdoc.corp.google.com/eng/doc/devguide/cpp/styleguide.shtml?cl=head#...

[Sergey Ulanov, 2014/04/24 21:01:51]

They are not required, but they improve readability when there is else,
especially when you have a macro in the body.

BTW you can use "?:" here and then we wouldn't have this argument :)

[jiayl, 2014/04/24 21:27:35]

OK, "?:" wins.

+  else
+    UMA_HISTOGRAM_TIMES(kUMAWindowCaptureTime, capture_time);
+
   scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
 
   // Handle initial frame size and size changes.
   RefreshCaptureFormat(frame->size());
 
   webrtc::DesktopSize output_size(capture_format_.frame_size.width(),
                                   capture_format_.frame_size.height());
   size_t output_bytes = output_size.width() * output_size.height() *
       webrtc::DesktopFrame::kBytesPerPixel;
   const uint8_t* output_data = NULL;
@@ skipping 185 matching lines @@
   scoped_ptr<webrtc::DesktopCapturer> capturer;
 
   switch (source.type) {
     case DesktopMediaID::TYPE_SCREEN: {
       scoped_ptr<webrtc::ScreenCapturer> screen_capturer;
       screen_capturer.reset(webrtc::ScreenCapturer::Create(options));
       if (screen_capturer && screen_capturer->SelectScreen(source.id)) {
         capturer.reset(new webrtc::DesktopAndCursorComposer(
             screen_capturer.release(),
             webrtc::MouseCursorMonitor::CreateForScreen(options, source.id)));
+        IncrementCounter(SCREEN_CAPTURER_CREATED);
       }
       break;
     }
 
     case DesktopMediaID::TYPE_WINDOW: {
       scoped_ptr<webrtc::WindowCapturer> window_capturer(
           webrtc::WindowCapturer::Create(options));
       if (window_capturer && window_capturer->SelectWindow(source.id)) {
         window_capturer->BringSelectedWindowToFront();
         capturer.reset(new webrtc::DesktopAndCursorComposer(
             window_capturer.release(),
             webrtc::MouseCursorMonitor::CreateForWindow(options, source.id)));
+        IncrementCounter(WINDOW_CATPTURER_CREATED);
       }
       break;
     }
 
     default: {
       NOTREACHED();
     }
   }
 
   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();
 }
 
 void DesktopCaptureDevice::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   core_->AllocateAndStart(params, client.Pass());
 }
 
 void DesktopCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 void DesktopCaptureDevice::SetNotificationWindowId(
     gfx::NativeViewId window_id) {
   core_->SetNotificationWindowId(window_id);
 }
 
 }  // namespace content