Fix thread usage in chromoting host

remoting/host/session_manager.cc

 // 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.
 
 #include "remoting/host/session_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
@@ skipping 121 matching lines @@
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoGetInitInfo, client));
 }
 
 void SessionManager::RemoveClient(scoped_refptr<ClientConnection> client) {
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoRemoveClient, client));
 }
 
+void SessionManager::RemoveAllClients() {
+  network_loop_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &SessionManager::DoRemoveAllClients));
+}
+
 void SessionManager::DoCapture() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   // Make sure we have at most two oustanding recordings. We can simply return
   // if we can't make a capture now, the next capture will be started by the
   // end of an encode operation.
   if (recordings_ >= 2 || !started_)
     return;
 
   base::Time now = base::Time::Now();
   base::TimeDelta interval = base::TimeDelta::FromMilliseconds(
       static_cast<int>(base::Time::kMillisecondsPerSecond / rate_));
   base::TimeDelta elapsed = now - last_capture_time_;
 
   // If this method is called sonner than the required interval we return
   // immediately
   if (elapsed < interval)
     return;
 
   // At this point we are going to perform one capture so save the current time.
   last_capture_time_ = now;
   ++recordings_;
 
   // Before we actually do a capture, schedule the next one.
   ScheduleNextCapture();
 
   // And finally perform one capture.
-  DCHECK(capturer_.get());
-  capturer_->CaptureDirtyRects(
+  capturer()->CaptureDirtyRects(
       NewRunnableMethod(this, &SessionManager::CaptureDoneTask));
 }
 
 void SessionManager::DoFinishEncode() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   // Decrement the number of recording in process since we have completed
   // one cycle.
   --recordings_;
 
   // Try to do a capture again. Note that the following method may do nothing
   // if it is too early to perform a capture.
   if (rate_ > 0)
     DoCapture();
 }
 
 void SessionManager::DoEncode(const CaptureData *capture_data) {
   // Take ownership of capture_data.
   scoped_ptr<const CaptureData> capture_data_owner(capture_data);
 
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
-  DCHECK(encoder_.get());
-
   // TODO(hclam): Enable |force_refresh| if a new client was
   // added.
-  encoder_->SetSize(capture_data->width_, capture_data->height_);
-  encoder_->SetPixelFormat(capture_data->pixel_format_);
-  encoder_->Encode(
+  encoder()->SetSize(capture_data->width_, capture_data->height_);
+  encoder()->SetPixelFormat(capture_data->pixel_format_);
+  encoder()->Encode(
       capture_data->dirty_rects_,
       capture_data->data_,
       capture_data->data_strides_,
       false,
       NewCallback(this, &SessionManager::EncodeDataAvailableTask));
 }
 
 void SessionManager::DoSendUpdate(const UpdateStreamPacketHeader* header,
                                   const scoped_refptr<media::DataBuffer> data,
                                   Encoder::EncodingState state) {
@@ skipping 22 matching lines @@
   client->SendInitClientMessage(width, height);
 }
 
 void SessionManager::DoGetInitInfo(scoped_refptr<ClientConnection> client) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   // Sends the init message to the cleint.
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoSendInit, client,
-                        capturer_->GetWidth(), capturer_->GetHeight()));
+                        capturer()->GetWidth(), capturer()->GetHeight()));
 
   // And then add the client to the list so it can receive update stream.
   // It is important we do so in such order or the client will receive
   // update stream before init message.
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoAddClient, client));
 }
 
 void SessionManager::DoSetRate(double rate) {
@@ skipping 28 matching lines @@
   // TODO(hclam): Force a full frame for next encode.
   clients_.push_back(client);
 }
 
 void SessionManager::DoRemoveClient(scoped_refptr<ClientConnection> client) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // TODO(hclam): Is it correct to do to a scoped_refptr?
   ClientConnectionList::iterator it
       = std::find(clients_.begin(), clients_.end(), client);
-  if (it != clients_.end())
+  if (it != clients_.end()) {
     clients_.erase(it);
+  }
+}
+
+void SessionManager::DoRemoveAllClients() {
+  DCHECK_EQ(network_loop_, MessageLoop::current());
+
+  // Clear the list of clients.
+  clients_.clear();
 }
 
 void SessionManager::DoRateControl() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // If we have been paused then shutdown the rate regulation loop.
   if (!rate_control_started_)
     return;
 
   int max_pending_update_streams = 0;
@@ skipping 44 matching lines @@
       NewRunnableMethod(this, &SessionManager::DoRateControl),
       kRateControlInterval.InMilliseconds());
 }
 
 void SessionManager::CaptureDoneTask() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   scoped_ptr<CaptureData> data(new CaptureData);
 
   // Save results of the capture.
-  capturer_->GetData(data->data_);
-  capturer_->GetDataStride(data->data_strides_);
-  capturer_->GetDirtyRects(&data->dirty_rects_);
-  data->pixel_format_ = capturer_->GetPixelFormat();
-  data->width_ = capturer_->GetWidth();
-  data->height_ = capturer_->GetHeight();
+  capturer()->GetData(data->data_);
+  capturer()->GetDataStride(data->data_strides_);
+  capturer()->GetDirtyRects(&data->dirty_rects_);
+  data->pixel_format_ = capturer()->GetPixelFormat();
+  data->width_ = capturer()->GetWidth();
+  data->height_ = capturer()->GetHeight();
 
   encode_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoEncode, data.release()));
 }
 
 void SessionManager::EncodeDataAvailableTask(
     const UpdateStreamPacketHeader *header,
     const scoped_refptr<media::DataBuffer>& data,
     Encoder::EncodingState state) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   // Before a new encode task starts, notify clients a new update
   // stream is coming.
   // Notify this will keep a reference to the DataBuffer in the
   // task. The ownership will eventually pass to the ClientConnections.
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &SessionManager::DoSendUpdate,
                         header,
                         data,
                         state));
 
-  if (state == Encoder::EncodingEnded) {
+  if (state & Encoder::EncodingEnded) {
     capture_loop_->PostTask(
         FROM_HERE, NewRunnableMethod(this, &SessionManager::DoFinishEncode));
   }
 }
 
+Capturer* SessionManager::capturer() {
+  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  return capturer_.get();
+}
+
+Encoder* SessionManager::encoder() {
+  DCHECK_EQ(encode_loop_, MessageLoop::current());
+  return encoder_.get();
+}
+
 }  // namespace remoting