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

media/capture/content/screen_capture_device_core.h

 // 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.
 
 #ifndef MEDIA_CAPTURE_SCREEN_CAPTURE_DEVICE_CORE_H_
 #define MEDIA_CAPTURE_SCREEN_CAPTURE_DEVICE_CORE_H_
 
 #include <string>
 
 #include "base/macros.h"
@@ skipping 28 matching lines @@
 
   // Stops capturing.
   // |callback| is invoked after the capturing has stopped.
   virtual void Stop(const base::Closure& callback) = 0;
 
   // Returns true if the video capture is configured to monitor end-to-end
   // system utilization, and alter frame sizes and/or frame rates to mitigate
   // overloading or under-utilization.
   virtual bool IsAutoThrottlingEnabled() const;
 
+  // Called by ScreenCaptureDeviceCore when it failed to satisfy a "refresh
+  // frame" request by attempting to resurrect the last video frame from the
+  // buffer pool (this is referred to as the "passive" refresh approach).  The
+  // failure can happen for a number of reasons (e.g., the oracle decided to
+  // change resolution, or consumers of the last video frame are not yet
+  // finished with it).
+  //
+  // The implementation of this method should consult the oracle, using the
+  // kActiveRefreshRequest event type, to decide whether to initiate a new frame
+  // capture, and then do so if the oracle agrees.

[Irfan, 2016/04/06 19:53:05]

What happens when there is a request from consumer and the oracle for some
reason decides to not capture ?

Should this have been a force capture at oracle ? Should there be a response to
consumer when request cannot be honored ?

[miu, 2016/04/06 22:33:53]

Nothing happens.  The oracle will decide not to capture whenever the refresh
request is unnecessary (because there was recently a frame delivered and/or
there is high expectation there will soon be another delivered soon anyway).
No: This is best-effort, as explained in my other comment.

+  virtual void MaybeCaptureForRefresh() = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureMachine);
 };
 
 // The "meat" of a content video capturer.
 //
 // Separating this from the "shell classes" WebContentsVideoCaptureDevice and
 // DesktopCaptureDeviceAura allows safe destruction without needing to block any
 // threads, as well as code sharing.
 //
 // ScreenCaptureDeviceCore manages a simple state machine and the pipeline
 // (see notes at top of this file).  It times the start of successive captures
 // and facilitates the processing of each through the stages of the
 // pipeline.
 class MEDIA_EXPORT ScreenCaptureDeviceCore
     : public base::SupportsWeakPtr<ScreenCaptureDeviceCore> {
  public:
   ScreenCaptureDeviceCore(scoped_ptr<VideoCaptureMachine> capture_machine);
   virtual ~ScreenCaptureDeviceCore();
 
   // Asynchronous requests to change ScreenCaptureDeviceCore state.
   void AllocateAndStart(const VideoCaptureParams& params,
                         scoped_ptr<VideoCaptureDevice::Client> client);
+  void RequestRefreshFrame();
   void StopAndDeAllocate();
 
  private:
   // Flag indicating current state.
   enum State { kIdle, kCapturing, kError, kLastCaptureState };
 
   void TransitionStateTo(State next_state);
 
   // Called back in response to StartCaptureMachine().  |success| is true if
   // capture machine succeeded to start.
@@ skipping 18 matching lines @@
   // capture pipeline. Besides the VideoCaptureDevice itself, it is the only
   // component of the system with direct access to |client_|.
   scoped_refptr<ThreadSafeCaptureOracle> oracle_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenCaptureDeviceCore);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_CAPTURE_SCREEN_CAPTURE_DEVICE_CORE_H_