From Video Capture, abolish OnFrameInfo and enable resolution changes

content/browser/renderer_host/media/video_capture_controller.h

 // 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.
 //
 // VideoCaptureController is the glue between a VideoCaptureDevice and all
 // VideoCaptureHosts that have connected to it. A controller exists on behalf of
 // one (and only one) VideoCaptureDevice; both are owned by the
 // VideoCaptureManager.
 //
 // The VideoCaptureController is responsible for:
@@ skipping 60 matching lines @@
  public:
   VideoCaptureController();
   virtual ~VideoCaptureController();
 
   base::WeakPtr<VideoCaptureController> GetWeakPtr();
 
   // Return a new VideoCaptureDeviceClient to forward capture events to this
   // instance.
   scoped_ptr<media::VideoCaptureDevice::Client> NewDeviceClient();
 
-  // Start video capturing and try to use the resolution specified in
-  // |params|.
-  // When capturing starts, the |event_handler| will receive an OnFrameInfo()
-  // call informing it of the resolution that was actually picked by the device.
+  // Start video capturing and try to use the resolution specified in |params|.
+  // Buffers will be shared to the client as necessary. The client will continue
+  // to receive frames from the device until RemoveClient() is called.
   void AddClient(const VideoCaptureControllerID& id,

[sheu, 2013/10/12 00:37:52]

It's confusing to have AddClient()/RemoveClient() named as such, when the Client
they refer to is actually the internal ControllerClient class and not the
external media::VideoCaptureDevice::Client class.

[ncarter (slow), 2013/10/16 02:08:40]

It's not relevant to this CL, but the intent here was to rename
VideoCaptureControllerEventHandler to VideoCaptureControllerClient. There are
client relationships all the way down. This is discussed in the refactoring
proposal doc.

                  VideoCaptureControllerEventHandler* event_handler,
                  base::ProcessHandle render_process,
                  const media::VideoCaptureParams& params);
 
   // Stop video capture. This will take back all buffers held by by
   // |event_handler|, and |event_handler| shouldn't use those buffers any more.
   // Returns the session_id of the stopped client, or
   // kInvalidMediaCaptureSessionId if the indicated client was not registered.
   int RemoveClient(const VideoCaptureControllerID& id,

[sheu, 2013/10/12 00:37:52]

(see above)

[ncarter (slow), 2013/10/16 02:08:40]

Done.

                    VideoCaptureControllerEventHandler* event_handler);
 
   int GetClientCount();
 
   // API called directly by VideoCaptureManager in case the device is
   // prematurely closed.
   void StopSession(int session_id);
 
   // Return a buffer previously given in
   // VideoCaptureControllerEventHandler::OnBufferReady.
   void ReturnBuffer(const VideoCaptureControllerID& id,
                     VideoCaptureControllerEventHandler* event_handler,
                     int buffer_id);
 
  private:
   class VideoCaptureDeviceClient;
 
   struct ControllerClient;
   typedef std::list<ControllerClient*> ControllerClients;
 
   // Worker functions on IO thread. Called by the VideoCaptureDeviceClient.
   void DoIncomingCapturedFrameOnIOThread(
       const scoped_refptr<media::VideoFrame>& captured_frame,
+      int frame_rate,
       base::Time timestamp);
-  void DoFrameInfoOnIOThread(
-      const media::VideoCaptureCapability& frame_info,
-      const scoped_refptr<VideoCaptureBufferPool>& buffer_pool);
-  void DoFrameInfoChangedOnIOThread(const media::VideoCaptureCapability& info);
   void DoErrorOnIOThread();
   void DoDeviceStoppedOnIOThread();
-
-  // Send frame info and init buffers to |client|.
-  void SendFrameInfoAndBuffers(ControllerClient* client);
+  void DoBufferDestroyedOnIOThread(int buffer_id_to_drop);
 
   // Find a client of |id| and |handler| in |clients|.
   ControllerClient* FindClient(
       const VideoCaptureControllerID& id,
       VideoCaptureControllerEventHandler* handler,
       const ControllerClients& clients);
 
   // Find a client of |session_id| in |clients|.
   ControllerClient* FindClient(
       int session_id,
       const ControllerClients& clients);
 
   // The pool of shared-memory buffers used for capturing.
-  scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
+  const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
 
   // All clients served by this controller.
   ControllerClients controller_clients_;
 
-  // The parameter that currently used for the capturing.
-  media::VideoCaptureParams current_params_;
-
-  // Tracks the current frame format.
-  media::VideoCaptureCapability frame_info_;
-
   // Takes on only the states 'STARTED' and 'ERROR'. 'ERROR' is an absorbing
   // state which stops the flow of data to clients.
   VideoCaptureState state_;
 
   base::WeakPtrFactory<VideoCaptureController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureController);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_