Tab/Desktop Capture: Use requests instead of timer-based refreshing.

media/capture/content/thread_safe_capture_oracle.cc

 // Copyright 2014 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 "media/capture/content/thread_safe_capture_oracle.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace media {
@@ skipping 26 matching lines @@
 
 bool ThreadSafeCaptureOracle::ObserveEventAndDecideCapture(
     VideoCaptureOracle::Event event,
     const gfx::Rect& damage_rect,
     base::TimeTicks event_time,
     scoped_refptr<VideoFrame>* storage,
     CaptureFrameCallback* callback) {
   // Grab the current time before waiting to acquire the |lock_|.
   const base::TimeTicks capture_begin_time = base::TimeTicks::Now();
 
-  base::AutoLock guard(lock_);
+  gfx::Size visible_size;
+  gfx::Size coded_size;
+  scoped_ptr<media::VideoCaptureDevice::Client::Buffer> output_buffer;
+  double attenuated_utilization;
+  int frame_number;
+  base::TimeDelta estimated_frame_duration;
+  {
+    base::AutoLock guard(lock_);
 
-  if (!client_)
-    return false;  // Capture is stopped.
+    if (!client_)
+      return false;  // Capture is stopped.
 
-  const bool should_capture =
-      oracle_.ObserveEventAndDecideCapture(event, damage_rect, event_time);
-  const gfx::Size visible_size = oracle_.capture_size();
-  // TODO(miu): Clients should request exact padding, instead of this
-  // memory-wasting hack to make frames that are compatible with all HW
-  // encoders.  http://crbug.com/555911
-  const gfx::Size coded_size(base::bits::Align(visible_size.width(), 16),
-                             base::bits::Align(visible_size.height(), 16));
-
-  scoped_ptr<media::VideoCaptureDevice::Client::Buffer> output_buffer(
-      client_->ReserveOutputBuffer(coded_size,
-                                   params_.requested_format.pixel_format,
-                                   params_.requested_format.pixel_storage));
-  // Get the current buffer pool utilization and attenuate it: The utilization
-  // reported to the oracle is in terms of a maximum sustainable amount (not the
-  // absolute maximum).
-  const double attenuated_utilization =
-      client_->GetBufferPoolUtilization() *
-      (100.0 / kTargetMaxPoolUtilizationPercent);
-
-  const char* event_name =
-      (event == VideoCaptureOracle::kTimerPoll
-           ? "poll"
-           : (event == VideoCaptureOracle::kCompositorUpdate ? "gpu"
-                                                             : "unknown"));
-
-  // Consider the various reasons not to initiate a capture.
-  if (should_capture && !output_buffer.get()) {
-    TRACE_EVENT_INSTANT1("gpu.capture", "PipelineLimited",
-                         TRACE_EVENT_SCOPE_THREAD, "trigger", event_name);
-    oracle_.RecordWillNotCapture(attenuated_utilization);
-    return false;
-  } else if (!should_capture && output_buffer.get()) {
-    if (event == VideoCaptureOracle::kCompositorUpdate) {
+    if (!oracle_.ObserveEventAndDecideCapture(event, damage_rect, event_time)) {
       // This is a normal and acceptable way to drop a frame. We've hit our
       // capture rate limit: for example, the content is animating at 60fps but
       // we're capturing at 30fps.
       TRACE_EVENT_INSTANT1("gpu.capture", "FpsRateLimited",
-                           TRACE_EVENT_SCOPE_THREAD, "trigger", event_name);
+                           TRACE_EVENT_SCOPE_THREAD, "trigger",
+                           VideoCaptureOracle::EventAsString(event));
+      return false;
     }
-    return false;
-  } else if (!should_capture && !output_buffer.get()) {
-    // We decided not to capture, but we wouldn't have been able to if we wanted
-    // to because no output buffer was available.
-    TRACE_EVENT_INSTANT1("gpu.capture", "NearlyPipelineLimited",
-                         TRACE_EVENT_SCOPE_THREAD, "trigger", event_name);
-    return false;
+
+    visible_size = oracle_.capture_size();
+    // TODO(miu): Clients should request exact padding, instead of this
+    // memory-wasting hack to make frames that are compatible with all HW
+    // encoders.  http://crbug.com/555911
+    coded_size.SetSize(base::bits::Align(visible_size.width(), 16),
+                       base::bits::Align(visible_size.height(), 16));
+
+    if (event == VideoCaptureOracle::kPassiveRefreshRequest) {
+      output_buffer = client_->ResurrectLastOutputBuffer(
+          coded_size, params_.requested_format.pixel_format,
+          params_.requested_format.pixel_storage);
+      if (!output_buffer) {
+        TRACE_EVENT_INSTANT0("gpu.capture", "ResurrectionFailed",
+                             TRACE_EVENT_SCOPE_THREAD);
+        return false;
+      }
+    } else {
+      output_buffer = client_->ReserveOutputBuffer(
+          coded_size, params_.requested_format.pixel_format,
+          params_.requested_format.pixel_storage);
+    }
+
+    // Get the current buffer pool utilization and attenuate it: The utilization
+    // reported to the oracle is in terms of a maximum sustainable amount (not
+    // the absolute maximum).
+    attenuated_utilization = client_->GetBufferPoolUtilization() *
+                             (100.0 / kTargetMaxPoolUtilizationPercent);
+
+    if (!output_buffer) {
+      TRACE_EVENT_INSTANT2(
+          "gpu.capture", "PipelineLimited", TRACE_EVENT_SCOPE_THREAD, "trigger",
+          VideoCaptureOracle::EventAsString(event), "atten_util_percent",
+          base::saturated_cast<int>(attenuated_utilization * 100.0 + 0.5));
+      oracle_.RecordWillNotCapture(attenuated_utilization);
+      return false;
+    }
+
+    frame_number = oracle_.RecordCapture(attenuated_utilization);
+    estimated_frame_duration = oracle_.estimated_frame_duration();
+  }  // End of critical section.
+
+  if (attenuated_utilization >= 1.0) {
+    TRACE_EVENT_INSTANT2(
+        "gpu.capture", "NearlyPipelineLimited", TRACE_EVENT_SCOPE_THREAD,
+        "trigger", VideoCaptureOracle::EventAsString(event),
+        "atten_util_percent",
+        base::saturated_cast<int>(attenuated_utilization * 100.0 + 0.5));
   }
 
-  const int frame_number = oracle_.RecordCapture(attenuated_utilization);
   TRACE_EVENT_ASYNC_BEGIN2("gpu.capture", "Capture", output_buffer.get(),
-                           "frame_number", frame_number, "trigger", event_name);
+                           "frame_number", frame_number, "trigger",
+                           VideoCaptureOracle::EventAsString(event));
 
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, params_.requested_format.pixel_storage);
   *storage = VideoFrame::WrapExternalSharedMemory(
       params_.requested_format.pixel_format, coded_size,
       gfx::Rect(visible_size), visible_size,
       static_cast<uint8_t*>(output_buffer->data()),
       output_buffer->mapped_size(), base::SharedMemory::NULLHandle(), 0u,
       base::TimeDelta());
   if (!(*storage))
     return false;
-  *callback =
-      base::Bind(&ThreadSafeCaptureOracle::DidCaptureFrame, this, frame_number,
-                 base::Passed(&output_buffer), capture_begin_time,
-                 oracle_.estimated_frame_duration());
+  *callback = base::Bind(&ThreadSafeCaptureOracle::DidCaptureFrame, this,
+                         frame_number, base::Passed(&output_buffer),
+                         capture_begin_time, estimated_frame_duration);
+
   return true;
 }
 
+bool ThreadSafeCaptureOracle::AttemptPassiveRefresh() {
+  const base::TimeTicks refresh_time = base::TimeTicks::Now();
+
+  scoped_refptr<VideoFrame> frame;
+  CaptureFrameCallback capture_callback;
+  if (!ObserveEventAndDecideCapture(VideoCaptureOracle::kPassiveRefreshRequest,
+                                    gfx::Rect(), refresh_time, &frame,
+                                    &capture_callback)) {
+    return false;
+  }
+

[Irfan, 2016/04/06 23:00:21]

probably add a comment explaining why the capture itself is a no-op

+  capture_callback.Run(frame, refresh_time, true);
+  return true;
+}
+
 gfx::Size ThreadSafeCaptureOracle::GetCaptureSize() const {
   base::AutoLock guard(lock_);
   return oracle_.capture_size();
 }
 
 void ThreadSafeCaptureOracle::UpdateCaptureSize(const gfx::Size& source_size) {
   base::AutoLock guard(lock_);
   VLOG(1) << "Source size changed to " << source_size.ToString();
   oracle_.SetSourceSize(source_size);
 }
@@ skipping 12 matching lines @@
 }
 
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     int frame_number,
     scoped_ptr<VideoCaptureDevice::Client::Buffer> buffer,
     base::TimeTicks capture_begin_time,
     base::TimeDelta estimated_frame_duration,
     const scoped_refptr<VideoFrame>& frame,
     base::TimeTicks timestamp,
     bool success) {
-  base::AutoLock guard(lock_);
   TRACE_EVENT_ASYNC_END2("gpu.capture", "Capture", buffer.get(), "success",
                          success, "timestamp", timestamp.ToInternalValue());
 
+  base::AutoLock guard(lock_);
+
   if (oracle_.CompleteCapture(frame_number, success, &timestamp)) {
     TRACE_EVENT_INSTANT0("gpu.capture", "CaptureSucceeded",
                          TRACE_EVENT_SCOPE_THREAD);
 
     if (!client_)
       return;  // Capture is stopped.
 
     frame->metadata()->SetDouble(VideoFrameMetadata::FRAME_RATE,
                                  params_.requested_format.frame_rate);
     frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_BEGIN_TIME,
@@ skipping 18 matching lines @@
   // destructor.  |metadata| is still valid for read-access at this point.
   double utilization = -1.0;
   if (metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                           &utilization)) {
     base::AutoLock guard(lock_);
     oracle_.RecordConsumerFeedback(frame_number, utilization);
   }
 }
 
 }  // namespace media