Add a done task to ScreenRecorder::Stop()

remoting/host/screen_recorder.h

 // Copyright (c) 2010 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 REMOTING_HOST_SCREEN_RECORDER_H_
 #define REMOTING_HOST_SCREEN_RECORDER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 58 matching lines @@
                  MessageLoop* encode_loop,
                  MessageLoop* network_loop,
                  Capturer* capturer,
                  Encoder* encoder);
 
   virtual ~ScreenRecorder();
 
   // Start recording.
   void Start();
 
-  // Pause the recording session.
-  void Pause();
+  // Stop the recording session. |task| is executed when recording is fully
+  // stopped. This object cannot be used again after |task| is executed.
+  void Stop(Task* task);

[Sergey Ulanov, 2011/01/20 19:14:17]

I think we should call it |done_task|, or |done|, or |stop_done|. |task| is not
very meaningful.

[Alpha Left Google, 2011/01/20 19:32:08]

Done.

 
   // Set the maximum capture rate. This is denoted by number of updates
   // in one second. The actual system may run in a slower rate than the maximum
   // rate due to various factors, e.g. capture speed, encode speed and network
   // conditions.
   // This method should be called before Start() is called.
   void SetMaxRate(double rate);
 
   // Add a connection to this recording session.
   void AddConnection(scoped_refptr<protocol::ConnectionToClient> connection);
 
   // Remove a connection from receiving screen updates.
   void RemoveConnection(scoped_refptr<protocol::ConnectionToClient> connection);
 
   // Remove all connections.
   void RemoveAllConnections();
 
  private:
   // Getters for capturer and encoder.
   Capturer* capturer();
   Encoder* encoder();
 
   // Capturer thread ----------------------------------------------------------
 
   void DoStart();
-  void DoPause();
+  void DoStop(Task* task);
+  void DoCompleteStop(Task* task);
 
   void DoSetMaxRate(double max_rate);
 
   // Hepler method to schedule next capture using the current rate.
   void StartCaptureTimer();
 
   void DoCapture();
   void CaptureDoneCallback(scoped_refptr<CaptureData> capture_data);
-  void DoFinishSend();
+  void DoFinishOneRecording();
 
   // Network thread -----------------------------------------------------------
 
   // DoSendVideoPacket takes ownership of the |packet| and is responsible
   // for deleting it.
   void DoSendVideoPacket(VideoPacket* packet);
 
   void DoSendInit(scoped_refptr<protocol::ConnectionToClient> connection,
                   int width, int height);
 
   void DoAddConnection(scoped_refptr<protocol::ConnectionToClient> connection);
   void DoRemoveClient(scoped_refptr<protocol::ConnectionToClient> connection);
   void DoRemoveAllClients();
 
+  // Signal network thread to cease activities.
+  void DoStopOnNetworkThread(Task* task);
+
   // Callback for the last packet in one update. Deletes |packet| and
   // schedules next screen capture.
-  void OnFrameSent(VideoPacket* packet);
+  void FrameSentCallback(VideoPacket* packet);
 
   // Encoder thread -----------------------------------------------------------
 
   void DoEncode(scoped_refptr<CaptureData> capture_data);
 
-  // EncodeDataAvailableTask takes ownership of |packet|.
-  void EncodeDataAvailableTask(VideoPacket* packet);
+  // Perform stop operations on encode thread.
+  void DoStopOnEncodeThread(Task* task);
+
+  // EncodedDataAvailableCallback takes ownership of |packet|.
+  void EncodedDataAvailableCallback(VideoPacket* packet);
   void SendVideoPacket(VideoPacket* packet);
 
   // Message loops used by this class.
   MessageLoop* capture_loop_;
   MessageLoop* encode_loop_;
   MessageLoop* network_loop_;
 
   // Reference to the capturer. This member is always accessed on the capture
   // thread.
   scoped_ptr<Capturer> capturer_;
 
   // Reference to the encoder. This member is always accessed on the encode
   // thread.
   scoped_ptr<Encoder> encoder_;
 
   // A list of clients connected to this hosts.
   // This member is always accessed on the NETWORK thread.
   // TODO(hclam): Have to scoped_refptr the clients since they have a shorter
   // lifetime than this object.
   typedef std::vector<scoped_refptr<protocol::ConnectionToClient> >
       ConnectionToClientList;
   ConnectionToClientList connections_;
 
-  // The following members are accessed on the capture thread.
+  // Flag that indicates recording has been started.
   bool started_;
 
+  // Flag that indicates network is being stopped.
+  bool network_stopped_;
+
   // Timer that calls DoCapture.
   base::RepeatingTimer<ScreenRecorder> capture_timer_;
 
   // Count the number of recordings (i.e. capture or encode) happening.
   int recordings_;
 
   // Set to true if we've skipped last capture because there are too
   // many pending frames.
   int frame_skipped_;
 
   // Number of captures to perform every second. Written on the capture thread.
   double max_rate_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenRecorder);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_SCREEN_RECORDER_H_