Adds UMA histograms for desktop tab and audio capture through

content/browser/media/capture/web_contents_video_capture_device.cc

 // Copyright (c) 2012 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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the client's
@@ skipping 51 matching lines @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/cursor_renderer.h"
+#include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/browser/media/capture/web_contents_tracker.h"
 #include "content/browser/media/capture/window_activity_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_media_capture_id.h"
@@ skipping 171 matching lines @@
     const SkBitmap& input,
     const scoped_refptr<media::VideoFrame>& output,
     const base::Callback<void(const gfx::Rect&, bool)>& done_cb);
 
 // Renews capture subscriptions based on feedback from WebContentsTracker, and
 // also executes copying of the backing store on the UI BrowserThread.
 class WebContentsCaptureMachine : public media::VideoCaptureMachine {
  public:
   WebContentsCaptureMachine(int render_process_id,
                             int main_render_frame_id,
-                            bool enable_auto_throttling);
+                            bool enable_auto_throttling,
+                            WebContentsVideoCaptureDevice::JavaScriptType type);
   ~WebContentsCaptureMachine() override;
 
   // VideoCaptureMachine overrides.
   void Start(const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
              const media::VideoCaptureParams& params,
              const base::Callback<void(bool)> callback) override;
   void Stop(const base::Closure& callback) override;
   bool IsAutoThrottlingEnabled() const override {
     return auto_throttling_enabled_;
   }
@@ skipping 48 matching lines @@
 
   // Tracks events and calls back to RenewFrameSubscription() to maintain
   // capture on the correct RenderWidgetHost.
   const scoped_refptr<WebContentsTracker> tracker_;
 
   // Set to false to prevent the capture size from automatically adjusting in
   // response to end-to-end utilization.  This is enabled via the throttling
   // option in the WebContentsVideoCaptureDevice device ID.
   const bool auto_throttling_enabled_;
 
+  bool is_first_capture_;
+  const WebContentsVideoCaptureDevice::JavaScriptType js_type_;
+
   // A dedicated worker thread on which SkBitmap->VideoFrame conversion will
   // occur. Only used when this activity cannot be done on the GPU.
   scoped_ptr<base::Thread> render_thread_;
 
   // Makes all the decisions about which frames to copy, and how.
   scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
 
   // Video capture parameters that this machine is started with.
   media::VideoCaptureParams capture_params_;
 
@@ skipping 280 matching lines @@
               << "WebContentsVideoCaptureDevice is " << measured_fps << " FPS.";
       last_frame_rate_log_time_ = frame_time;
       count_frames_rendered_ = 0;
     }
   }
 }
 
 WebContentsCaptureMachine::WebContentsCaptureMachine(
     int render_process_id,
     int main_render_frame_id,
-    bool enable_auto_throttling)
+    bool enable_auto_throttling,
+    WebContentsVideoCaptureDevice::JavaScriptType type)
     : initial_render_process_id_(render_process_id),
       initial_main_render_frame_id_(main_render_frame_id),
       tracker_(new WebContentsTracker(true)),
       auto_throttling_enabled_(enable_auto_throttling),
+      js_type_(type),
       weak_ptr_factory_(this) {
   DVLOG(1) << "Created WebContentsCaptureMachine for "
            << render_process_id << ':' << main_render_frame_id
            << (auto_throttling_enabled_ ? " with auto-throttling enabled" : "");
 }
 
 WebContentsCaptureMachine::~WebContentsCaptureMachine() {}
 
 bool WebContentsCaptureMachine::IsStarted() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return weak_ptr_factory_.HasWeakPtrs();
 }
 
 void WebContentsCaptureMachine::Start(
     const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params,
     const base::Callback<void(bool)> callback) {
+  is_first_capture_ = true;
+
   // Starts the capture machine asynchronously.
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebContentsCaptureMachine::InternalStart,
                  base::Unretained(this),
                  oracle_proxy,
                  params),
       callback);
 }
@@ skipping 195 matching lines @@
                                  "Render");
     render_thread_->task_runner()->PostTask(
         FROM_HERE, media::BindToCurrentLoop(
             base::Bind(&RenderVideoFrame, bitmap, target,
                               base::Bind(deliver_frame_cb, start_time))));
   } else {
     // Capture can fail due to transient issues, so just skip this frame.
     DVLOG(1) << "CopyFromBackingStore failed; skipping frame.";
     deliver_frame_cb.Run(start_time, gfx::Rect(), false);
   }
+
+  if (is_first_capture_) {
+    is_first_capture_ = false;
+    if (js_type_ ==
+        WebContentsVideoCaptureDevice::CHROME_CHOOSE_DESKTOP_MEDIA) {
+      if (response == READBACK_SUCCESS)

[miu, 2016/03/24 20:51:02]

It's very possible for the first few frames to fail, and this would be normal
behavior.  This is one reason why it doesn't seem useful to UMA-count the first
frame capture (see comment below).

[GeorgeZ, 2016/03/25 16:35:04]

Very valuable comments. I guess this is why a owner's review is necessary.

I will revert all the changes in web_contents_video_capture_device*.*

+        IncrementDesktopCaptureCounter(FIRST_TAB_CAPTURE_SUCCEEDED);
+      else
+        IncrementDesktopCaptureCounter(FIRST_TAB_CAPTURE_FAILED);
+    }
+  }
 }
 
 void WebContentsCaptureMachine::DidCopyFromCompositingSurfaceToVideoFrame(
     const base::TimeTicks& start_time,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb,
     const gfx::Rect& region_in_frame,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::TimeTicks now = base::TimeTicks::Now();
 
   if (success) {
     UMA_HISTOGRAM_TIMES("TabCapture.CopyTimeVideoFrame", now - start_time);
   } else {
     // Capture can fail due to transient issues, so just skip this frame.
     DVLOG(1) << "CopyFromCompositingSurface failed; skipping frame.";
   }
+
+  if (is_first_capture_) {
+    is_first_capture_ = false;
+    if (js_type_ ==
+        WebContentsVideoCaptureDevice::CHROME_CHOOSE_DESKTOP_MEDIA) {
+      if (success)
+        IncrementDesktopCaptureCounter(FIRST_TAB_CAPTURE_SUCCEEDED);
+      else
+        IncrementDesktopCaptureCounter(FIRST_TAB_CAPTURE_FAILED);
+    }
+  }
+
   deliver_frame_cb.Run(start_time, region_in_frame, success);
 }
 
 void WebContentsCaptureMachine::RenewFrameSubscription(bool had_target) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderWidgetHost* const rwh =
       had_target ? tracker_->GetTargetRenderWidgetHost() : nullptr;
 
   // Always destroy the old subscription before creating a new one.
@@ skipping 44 matching lines @@
           << ") from view size (" << view_size.ToString() << ").";
 
   oracle_proxy_->UpdateCaptureSize(physical_size);
 }
 
 }  // namespace
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     int render_process_id,
     int main_render_frame_id,
-    bool enable_auto_throttling)
+    bool enable_auto_throttling,
+    JavaScriptType type)
     : core_(new media::ScreenCaptureDeviceCore(
-          scoped_ptr<media::VideoCaptureMachine>(new WebContentsCaptureMachine(
-              render_process_id,
-              main_render_frame_id,
-              enable_auto_throttling)))) {}
+          scoped_ptr<media::VideoCaptureMachine>(
+              new WebContentsCaptureMachine(render_process_id,
+                                            main_render_frame_id,
+                                            enable_auto_throttling,
+                                            type)))) {}
 
 WebContentsVideoCaptureDevice::~WebContentsVideoCaptureDevice() {
   DVLOG(2) << "WebContentsVideoCaptureDevice@" << this << " destroying.";
 }
 
 // static
 media::VideoCaptureDevice* WebContentsVideoCaptureDevice::Create(
-    const std::string& device_id) {
+    const std::string& device_id,
+    JavaScriptType type) {
   // Parse device_id into render_process_id and main_render_frame_id.
   int render_process_id = -1;
   int main_render_frame_id = -1;
   if (!WebContentsMediaCaptureId::ExtractTabCaptureTarget(
           device_id, &render_process_id, &main_render_frame_id)) {
     return NULL;
   }
 
+  if (type == CHROME_CHOOSE_DESKTOP_MEDIA)
+    IncrementDesktopCaptureCounter(TAB_VIDEO_CAPTURER_CREATED);
+
   return new WebContentsVideoCaptureDevice(
       render_process_id, main_render_frame_id,
-      WebContentsMediaCaptureId::IsAutoThrottlingOptionSet(device_id));
+      WebContentsMediaCaptureId::IsAutoThrottlingOptionSet(device_id), type);
 }
 
 void WebContentsVideoCaptureDevice::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   core_->AllocateAndStart(params, std::move(client));
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content