Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

remoting/host/screen_recorder.cc

Index: remoting/host/screen_recorder.cc
diff --git a/remoting/host/screen_recorder.cc b/remoting/host/screen_recorder.cc
index e7b414c9afbe0d909bfd7806ad10bb00fbdb1bc3..20b305a9de9f5e541a71ceb303fcb2bc2d825e05 100644
--- a/remoting/host/screen_recorder.cc
+++ b/remoting/host/screen_recorder.cc
@@ -32,14 +32,14 @@ namespace remoting {
 static const int kMaxRecordings = 2;
 
 ScreenRecorder::ScreenRecorder(
-    MessageLoop* capture_loop,
-    MessageLoop* encode_loop,
-    base::MessageLoopProxy* network_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     Capturer* capturer,
     Encoder* encoder)
-    : capture_loop_(capture_loop),
-      encode_loop_(encode_loop),
-      network_loop_(network_loop),
+    : capture_task_runner_(capture_task_runner),
+      encode_task_runner_(encode_task_runner),
+      network_task_runner_(network_task_runner),
       capturer_(capturer),
       encoder_(encoder),
       network_stopped_(false),
@@ -48,21 +48,21 @@ ScreenRecorder::ScreenRecorder(
       recordings_(0),
       frame_skipped_(false),
       sequence_number_(0) {
-  DCHECK(capture_loop_);
-  DCHECK(encode_loop_);
-  DCHECK(network_loop_);
+  DCHECK(capture_task_runner_);
+  DCHECK(encode_task_runner_);
+  DCHECK(network_task_runner_);
 }
 
 // Public methods --------------------------------------------------------------
 
 void ScreenRecorder::Start() {
-  capture_loop_->PostTask(
+  capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoStart, this));
 }
 
 void ScreenRecorder::Stop(const base::Closure& done_task) {
-  if (MessageLoop::current() != capture_loop_) {
-    capture_loop_->PostTask(FROM_HERE, base::Bind(
+  if (!capture_task_runner_->BelongsToCurrentThread()) {
+    capture_task_runner_->PostTask(FROM_HERE, base::Bind(
         &ScreenRecorder::Stop, this, done_task));
     return;
   }
@@ -72,20 +72,20 @@ void ScreenRecorder::Stop(const base::Closure& done_task) {
   capturer()->Stop();
   capture_timer_.reset();
 
-  network_loop_->PostTask(FROM_HERE, base::Bind(
+  network_task_runner_->PostTask(FROM_HERE, base::Bind(
       &ScreenRecorder::DoStopOnNetworkThread, this, done_task));
 }
 
 void ScreenRecorder::AddConnection(ConnectionToClient* connection) {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
   connections_.push_back(connection);
 
-  capture_loop_->PostTask(
+  capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoInvalidateFullScreen, this));
 }
 
 void ScreenRecorder::RemoveConnection(ConnectionToClient* connection) {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   ConnectionToClientList::iterator it =
       std::find(connections_.begin(), connections_.end(), connection);
@@ -95,14 +95,14 @@ void ScreenRecorder::RemoveConnection(ConnectionToClient* connection) {
 }
 
 void ScreenRecorder::RemoveAllConnections() {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
   connections_.clear();
 }
 
 void ScreenRecorder::UpdateSequenceNumber(int64 sequence_number) {
   // Sequence number is used and written only on the capture thread.
-  if (MessageLoop::current() != capture_loop_) {
-    capture_loop_->PostTask(
+  if (!capture_task_runner_->BelongsToCurrentThread()) {
+    capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ScreenRecorder::UpdateSequenceNumber,
                               this, sequence_number));
     return;
@@ -117,26 +117,26 @@ ScreenRecorder::~ScreenRecorder() {
 }
 
 Capturer* ScreenRecorder::capturer() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK(capturer_);
   return capturer_;
 }
 
 Encoder* ScreenRecorder::encoder() {
-  DCHECK_EQ(encode_loop_, MessageLoop::current());
+  DCHECK(encode_task_runner_->BelongsToCurrentThread());
   DCHECK(encoder_.get());
   return encoder_.get();
 }
 
 bool ScreenRecorder::is_recording() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
   return capture_timer_.get() != NULL;
 }
 
 // Capturer thread -------------------------------------------------------------
 
 void ScreenRecorder::DoStart() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (is_recording()) {
     NOTREACHED() << "Record session already started.";
@@ -153,7 +153,7 @@ void ScreenRecorder::DoStart() {
 }
 
 void ScreenRecorder::StartCaptureTimer() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   capture_timer_->Start(FROM_HERE,
                         scheduler_.NextCaptureDelay(),
@@ -162,7 +162,7 @@ void ScreenRecorder::StartCaptureTimer() {
 }
 
 void ScreenRecorder::DoCapture() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
   // 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.
@@ -193,7 +193,7 @@ void ScreenRecorder::DoCapture() {
 
 void ScreenRecorder::CaptureDoneCallback(
     scoped_refptr<CaptureData> capture_data) {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (!is_recording())
     return;
@@ -213,24 +213,24 @@ void ScreenRecorder::CaptureDoneCallback(
     capture_data->set_client_sequence_number(sequence_number_);
   }
 
-  encode_loop_->PostTask(
+  encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoEncode, this, capture_data));
 }
 
 void ScreenRecorder::CursorShapeChangedCallback(
     scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (!is_recording())
     return;
 
-  network_loop_->PostTask(
+  network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoSendCursorShape, this,
                             base::Passed(cursor_shape.Pass())));
 }
 
 void ScreenRecorder::DoFinishOneRecording() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (!is_recording())
     return;
@@ -247,7 +247,7 @@ void ScreenRecorder::DoFinishOneRecording() {
 }
 
 void ScreenRecorder::DoInvalidateFullScreen() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   capturer_->InvalidateFullScreen();
 }
@@ -255,7 +255,7 @@ void ScreenRecorder::DoInvalidateFullScreen() {
 // Network thread --------------------------------------------------------------
 
 void ScreenRecorder::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (network_stopped_ || connections_.empty())
     return;
@@ -271,17 +271,17 @@ void ScreenRecorder::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
 }
 
 void ScreenRecorder::VideoFrameSentCallback() {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (network_stopped_)
     return;
 
-  capture_loop_->PostTask(
+  capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoFinishOneRecording, this));
 }
 
 void ScreenRecorder::DoStopOnNetworkThread(const base::Closure& done_task) {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // There could be tasks on the network thread when this method is being
   // executed. By setting the flag we'll not post anymore tasks from network
@@ -291,14 +291,14 @@ void ScreenRecorder::DoStopOnNetworkThread(const base::Closure& done_task) {
   // sequence.
   network_stopped_ = true;
 
-  encode_loop_->PostTask(
+  encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoStopOnEncodeThread,
                             this, done_task));
 }
 
 void ScreenRecorder::DoSendCursorShape(
     scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
-  DCHECK(network_loop_->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (network_stopped_ || connections_.empty())
     return;
@@ -312,7 +312,7 @@ void ScreenRecorder::DoSendCursorShape(
 
 void ScreenRecorder::DoEncode(
     scoped_refptr<CaptureData> capture_data) {
-  DCHECK_EQ(encode_loop_, MessageLoop::current());
+  DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   if (encoder_stopped_)
     return;
@@ -322,7 +322,7 @@ void ScreenRecorder::DoEncode(
     // Send an empty video packet to keep network active.
     scoped_ptr<VideoPacket> packet(new VideoPacket());
     packet->set_flags(VideoPacket::LAST_PARTITION);
-    network_loop_->PostTask(
+    network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket,
                               this, base::Passed(packet.Pass())));
     return;
@@ -335,19 +335,19 @@ void ScreenRecorder::DoEncode(
 }
 
 void ScreenRecorder::DoStopOnEncodeThread(const base::Closure& done_task) {
-  DCHECK_EQ(encode_loop_, MessageLoop::current());
+  DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   encoder_stopped_ = true;
 
   // When this method is being executed there are no more tasks on encode thread
   // for this object. We can then post a task to capture thread to finish the
   // stop sequence.
-  capture_loop_->PostTask(FROM_HERE, done_task);
+  capture_task_runner_->PostTask(FROM_HERE, done_task);
 }
 
 void ScreenRecorder::EncodedDataAvailableCallback(
     scoped_ptr<VideoPacket> packet) {
-  DCHECK_EQ(encode_loop_, MessageLoop::current());
+  DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   if (encoder_stopped_)
     return;
@@ -361,7 +361,7 @@ void ScreenRecorder::EncodedDataAvailableCallback(
     scheduler_.RecordEncodeTime(encode_time);
   }
 
-  network_loop_->PostTask(
+  network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
                             base::Passed(packet.Pass())));
 }