Fix thread usage in chromoting host

remoting/host/session_manager.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_RECORD_SESSION_H_
 #define REMOTING_HOST_RECORD_SESSION_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 49 matching lines @@
 // v
 //
 // SessionManager has the following responsibilities:
 // 1. Make sure capture and encode occurs no more frequently than |rate|.
 // 2. Make sure there is at most one outstanding capture not being encoded.
 // 3. Distribute tasks on three threads on a timely fashion to minimize latency.
 class SessionManager : public base::RefCountedThreadSafe<SessionManager> {
  public:
 
   // Construct a SessionManager. Message loops and threads are provided.
-  // Ownership of Capturer and Encoder are given to this object.
+  // This object does not own capturer and encoder.
   SessionManager(MessageLoop* capture_loop,
                  MessageLoop* encode_loop,
                  MessageLoop* network_loop,
                  Capturer* capturer,
                  Encoder* encoder);
 
   virtual ~SessionManager();
 
   // Start recording.
   void Start();
 
   // Pause the recording session.
   void Pause();
 
   // 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 client to this recording session.
   void AddClient(scoped_refptr<ClientConnection> client);
 
   // Remove a client from receiving screen updates.
   void RemoveClient(scoped_refptr<ClientConnection> client);
 
+  // Remove all clients.
+  void RemoveAllClients();
+
  private:
 
   // Stores the data and information of a capture to pass off to the
   // encoding thread.
   struct CaptureData {
     DirtyRects dirty_rects_;
     const uint8* data_[3];
     int data_strides_[3];
     int width_;
     int height_;
@@ skipping 15 matching lines @@
   void DoSendUpdate(const UpdateStreamPacketHeader* header,
                     const scoped_refptr<media::DataBuffer> data,
                     Encoder::EncodingState state);
   void DoSendInit(scoped_refptr<ClientConnection> client,
                   int width, int height);
   void DoGetInitInfo(scoped_refptr<ClientConnection> client);
   void DoSetRate(double rate);
   void DoSetMaxRate(double max_rate);
   void DoAddClient(scoped_refptr<ClientConnection> client);
   void DoRemoveClient(scoped_refptr<ClientConnection> client);
+  void DoRemoveAllClients();
   void DoRateControl();
 
   // Hepler method to schedule next capture using the current rate.
   void ScheduleNextCapture();
 
   // Helper method to schedule next rate regulation task.
   void ScheduleNextRateControl();
 
   void CaptureDoneTask();
   // EncodeDataAvailableTask takes ownership of header and is responsible for
   // deleting it.
   void EncodeDataAvailableTask(const UpdateStreamPacketHeader *header,
                                const scoped_refptr<media::DataBuffer>& data,
                                Encoder::EncodingState state);
 
+  // Getters for capturer and encoder.
+  Capturer* capturer();
+  Encoder* encoder();
+
   // 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
@@ skipping 20 matching lines @@
 
   // The following member is accessed on the network thread.
   bool rate_control_started_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionManager);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_RECORD_SESSION_H_