Clean-up: Remove unused logging/UMA's from web_contents_video_capture_device.cc.

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 26 matching lines @@
 // system is designed so that Capture and Render may run concurrently. A timing
 // diagram helps illustrate this point (@30 FPS):
 //
 //    Time: 0ms                 33ms                 66ms                 99ms
 // thread1: |-Capture-f1------v |-Capture-f2------v  |-Capture-f3----v    |-Capt
 // thread2:                   |-Render-f1-----v   |-Render-f2-----v  |-Render-f3
 //
 // In the above example, both capturing and rendering *each* take almost the
 // full 33 ms available between frames, yet we see that the required throughput
 // is obtained.
-//
-// Turning on verbose logging will cause the effective frame rate to be logged
-// at 5-second intervals.
 
 #include "content/browser/media/capture/web_contents_video_capture_device.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
-#include "base/metrics/histogram_macros.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/web_contents_tracker.h"
 #include "content/browser/media/capture/window_activity_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
@@ skipping 31 matching lines @@
 };
 
 void DeleteOnWorkerThread(std::unique_ptr<base::Thread> render_thread,
                           const base::Closure& callback) {
   render_thread.reset();
 
   // After thread join call the callback on UI thread.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
-// Responsible for logging the effective frame rate.
-class VideoFrameDeliveryLog {
- public:
-  VideoFrameDeliveryLog();
-
-  // Report that the frame posted with |frame_time| has been delivered.
-  void ChronicleFrameDelivery(base::TimeTicks frame_time);
-
- private:
-  // The following keep track of and log the effective frame rate whenever
-  // verbose logging is turned on.
-  base::TimeTicks last_frame_rate_log_time_;
-  int count_frames_rendered_;
-
-  DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliveryLog);
-};
-
 // FrameSubscriber is a proxy to the ThreadSafeCaptureOracle that's compatible
 // with RenderWidgetHostViewFrameSubscriber. We create one per event type.
 class FrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FrameSubscriber(media::VideoCaptureOracle::Event event_type,
                   const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle,
-                  VideoFrameDeliveryLog* delivery_log,
                   base::WeakPtr<content::CursorRenderer> cursor_renderer,
                   base::WeakPtr<content::WindowActivityTracker> tracker)
       : event_type_(event_type),
         oracle_proxy_(oracle),
-        delivery_log_(delivery_log),
         cursor_renderer_(cursor_renderer),
         window_activity_tracker_(tracker),
         weak_ptr_factory_(this) {}
 
   bool ShouldCaptureFrame(
       const gfx::Rect& damage_rect,
       base::TimeTicks present_time,
       scoped_refptr<media::VideoFrame>* storage,
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback*
           deliver_frame_cb) override;
 
   static void DidCaptureFrame(
       base::WeakPtr<FrameSubscriber> frame_subscriber_,
       const media::ThreadSafeCaptureOracle::CaptureFrameCallback&
           capture_frame_cb,
       const scoped_refptr<media::VideoFrame>& frame,
       base::TimeTicks timestamp,
       const gfx::Rect& region_in_frame,
       bool success);
 
   bool IsUserInteractingWithContent();
 
  private:
   const media::VideoCaptureOracle::Event event_type_;
   scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
-  VideoFrameDeliveryLog* const delivery_log_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the cursor renderer.
   base::WeakPtr<CursorRenderer> cursor_renderer_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the ui activity tracker.
   base::WeakPtr<WindowActivityTracker> window_activity_tracker_;
   base::WeakPtrFactory<FrameSubscriber> weak_ptr_factory_;
 };
 
 // ContentCaptureSubscription is the relationship between a RenderWidgetHost
@@ skipping 31 matching lines @@
  private:
   // Called for active frame refresh requests, or mouse activity events.
   void OnEvent(FrameSubscriber* subscriber);
 
   // Maintain a weak reference to the RenderWidgetHost (via its routing ID),
   // since the instance could be destroyed externally during the lifetime of
   // |this|.
   const int render_process_id_;
   const int render_widget_id_;
 
-  VideoFrameDeliveryLog delivery_log_;
   std::unique_ptr<FrameSubscriber> refresh_subscriber_;
   std::unique_ptr<FrameSubscriber> mouse_activity_subscriber_;
   CaptureCallback capture_callback_;
 
   // Responsible for tracking the cursor state and input events to make
   // decisions and then render the mouse cursor on the video frame after
   // capture is completed.
   std::unique_ptr<content::CursorRenderer> cursor_renderer_;
 
   // Responsible for tracking the UI events and making a decision on whether
@@ skipping 101 matching lines @@
   // A dedicated worker thread on which SkBitmap->VideoFrame conversion will
   // occur. Only used when this activity cannot be done on the GPU.
   std::unique_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_;
 
-  // Last known RenderView size.
-  gfx::Size last_view_size_;
-
   // Responsible for forwarding events from the active RenderWidgetHost to the
   // oracle, and initiating captures accordingly.
   std::unique_ptr<ContentCaptureSubscription> subscription_;
 
   // False while frame capture has been suspended. This prevents subscriptions
   // from being created by RenewFrameSubscription() until frame capture is
   // resumed.
   bool frame_capture_active_;
 
   // Weak pointer factory used to invalidate callbacks.
@@ skipping 13 matching lines @@
 
   media::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
 
   bool oracle_decision = oracle_proxy_->ObserveEventAndDecideCapture(
       event_type_, damage_rect, present_time, storage, &capture_frame_cb);
 
   if (!capture_frame_cb.is_null())
     *deliver_frame_cb =
         base::Bind(&FrameSubscriber::DidCaptureFrame,
                    weak_ptr_factory_.GetWeakPtr(), capture_frame_cb, *storage);
-  if (oracle_decision)
-    delivery_log_->ChronicleFrameDelivery(present_time);
   return oracle_decision;
 }
 
 void FrameSubscriber::DidCaptureFrame(
     base::WeakPtr<FrameSubscriber> frame_subscriber_,
     const media::ThreadSafeCaptureOracle::CaptureFrameCallback&
         capture_frame_cb,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp,
     const gfx::Rect& region_in_frame,
@@ skipping 38 matching lines @@
   }
   return interactive_mode;
 }
 
 ContentCaptureSubscription::ContentCaptureSubscription(
     const RenderWidgetHost& source,
     const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
     const CaptureCallback& capture_callback)
     : render_process_id_(source.GetProcess()->GetID()),
       render_widget_id_(source.GetRoutingID()),
-      delivery_log_(),
       capture_callback_(capture_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderWidgetHostView* const view = source.GetView();
 #if defined(USE_AURA) || defined(OS_MACOSX)
   if (view) {
     cursor_renderer_ = CursorRenderer::Create(view->GetNativeView());
     window_activity_tracker_ =
         WindowActivityTracker::Create(view->GetNativeView());
   }
 #endif
   refresh_subscriber_.reset(new FrameSubscriber(
       media::VideoCaptureOracle::kActiveRefreshRequest, oracle_proxy,
-      &delivery_log_,
       cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
                        : base::WeakPtr<CursorRenderer>(),
       window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                : base::WeakPtr<WindowActivityTracker>()));
   mouse_activity_subscriber_.reset(new FrameSubscriber(
       media::VideoCaptureOracle::kMouseCursorUpdate, oracle_proxy,
-      &delivery_log_, cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
-                                       : base::WeakPtr<CursorRenderer>(),
+      cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
+                       : base::WeakPtr<CursorRenderer>(),
       window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                : base::WeakPtr<WindowActivityTracker>()));
 
   // Subscribe to compositor updates. These will be serviced directly by the
   // oracle.
   if (view) {
     std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
         new FrameSubscriber(
             media::VideoCaptureOracle::kCompositorUpdate, oracle_proxy,
-            &delivery_log_, cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
-                                             : base::WeakPtr<CursorRenderer>(),
+            cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
+                             : base::WeakPtr<CursorRenderer>(),
             window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                      : base::WeakPtr<WindowActivityTracker>()));
     view->BeginFrameSubscription(std::move(subscriber));
   }
 
   // Subscribe to mouse movement and mouse cursor update events.
   if (window_activity_tracker_) {
     window_activity_tracker_->RegisterMouseInteractionObserver(
         base::Bind(&ContentCaptureSubscription::OnEvent, base::Unretained(this),
                    mouse_activity_subscriber_.get()));
@@ skipping 102 matching lines @@
     media::CopyRGBToVideoFrame(
         reinterpret_cast<uint8_t*>(scaled_bitmap.getPixels()),
         scaled_bitmap.rowBytes(), region_in_yv12_frame, output.get());
   }
 
   // The result is now ready.
   ignore_result(failure_handler.Release());
   done_cb.Run(region_in_frame, true);
 }
 
-VideoFrameDeliveryLog::VideoFrameDeliveryLog()
-    : last_frame_rate_log_time_(), count_frames_rendered_(0) {}
-
-void VideoFrameDeliveryLog::ChronicleFrameDelivery(base::TimeTicks frame_time) {
-  // Log frame rate, if verbose logging is turned on.
-  static const base::TimeDelta kFrameRateLogInterval =
-      base::TimeDelta::FromSeconds(10);
-  if (last_frame_rate_log_time_.is_null()) {
-    last_frame_rate_log_time_ = frame_time;
-    count_frames_rendered_ = 0;
-  } else {
-    ++count_frames_rendered_;
-    const base::TimeDelta elapsed = frame_time - last_frame_rate_log_time_;
-    if (elapsed >= kFrameRateLogInterval) {
-      const double measured_fps = count_frames_rendered_ / elapsed.InSecondsF();
-      UMA_HISTOGRAM_COUNTS("TabCapture.FrameRate",
-                           static_cast<int>(measured_fps));
-      VLOG(1) << "Current measured frame rate for "
-              << "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)
     : 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),
       frame_capture_active_(true),
       weak_ptr_factory_(this) {
@@ skipping 139 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderWidgetHost* rwh = tracker_->GetTargetRenderWidgetHost();
   RenderWidgetHostViewBase* view =
       rwh ? static_cast<RenderWidgetHostViewBase*>(rwh->GetView()) : NULL;
   if (!view) {
     deliver_frame_cb.Run(base::TimeTicks(), gfx::Rect(), false);
     return;
   }
 
-  gfx::Size view_size = view->GetViewBounds().size();
-  if (view_size != last_view_size_) {
-    last_view_size_ = view_size;
-
-    // Measure the number of kilopixels.
-    UMA_HISTOGRAM_COUNTS_10000("TabCapture.ViewChangeKiloPixels",
-                               view_size.width() * view_size.height() / 1024);
-  }
-
+  const gfx::Size view_size = view->GetViewBounds().size();
   if (view->CanCopyToVideoFrame()) {
     view->CopyFromCompositingSurfaceToVideoFrame(
         gfx::Rect(view_size), target,
         base::Bind(&WebContentsCaptureMachine::
                        DidCopyFromCompositingSurfaceToVideoFrame,
                    weak_ptr_factory_.GetWeakPtr(), start_time,
                    deliver_frame_cb));
   } else {
     const gfx::Size fitted_size =
         view_size.IsEmpty()
@@ skipping 78 matching lines @@
 
 void WebContentsCaptureMachine::DidCopyFromBackingStore(
     const base::TimeTicks& start_time,
     const scoped_refptr<media::VideoFrame>& target,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb,
     const SkBitmap& bitmap,
     ReadbackResponse response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  base::TimeTicks now = base::TimeTicks::Now();
   DCHECK(render_thread_);
   if (response == READBACK_SUCCESS) {
-    UMA_HISTOGRAM_TIMES("TabCapture.CopyTimeBitmap", now - start_time);
     TRACE_EVENT_ASYNC_STEP_INTO0("gpu.capture", "Capture", target.get(),
                                  "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);
   }
 }
 
 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.";
-  }
+  // Capture can fail due to transient issues, so just skip this frame.
+  DVLOG_IF(1, !success) << "CopyFromCompositingSurface failed; skipping frame.";
   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 92 matching lines @@
 
 void WebContentsVideoCaptureDevice::Resume() {
   core_->Resume();
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content