Use MessageLoopProxy for network message loop.

remoting/host/screen_recorder.cc

 // Copyright (c) 2011 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/screen_recorder.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "remoting/base/capture_data.h"
 #include "remoting/base/tracer.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/message_decoder.h"
 #include "remoting/protocol/util.h"
 
 using remoting::protocol::ConnectionToClient;
 
 namespace remoting {
 
 // By default we capture 20 times a second. This number is obtained by
 // experiment to provide good latency.
 static const double kDefaultCaptureRate = 20.0;
 
 // Maximum number of frames that can be processed similtaneously.
 // TODO(sergeyu): Should this be set to 1? Or should we change
 // dynamically depending on how fast network and CPU are? Experement
 // with it.
 static const int kMaxRecordings = 2;
 
 ScreenRecorder::ScreenRecorder(
     MessageLoop* capture_loop,
     MessageLoop* encode_loop,
-    MessageLoop* network_loop,
+    base::MessageLoopProxy* network_loop,
     Capturer* capturer,
     Encoder* encoder)
     : capture_loop_(capture_loop),
       encode_loop_(encode_loop),
       network_loop_(network_loop),
       capturer_(capturer),
       encoder_(encoder),
       is_recording_(false),
       network_stopped_(false),
       encoder_stopped_(false),
@@ skipping 216 matching lines @@
 
 void ScreenRecorder::DoInvalidateFullScreen() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   capturer_->InvalidateFullScreen();
 }
 
 // Network thread --------------------------------------------------------------
 
 void ScreenRecorder::DoSendVideoPacket(VideoPacket* packet) {
-  DCHECK_EQ(network_loop_, MessageLoop::current());
+  DCHECK(network_loop_->BelongsToCurrentThread());
 
   TraceContext::tracer()->PrintString("DoSendVideoPacket");
 
   bool last = (packet->flags() & VideoPacket::LAST_PARTITION) != 0;
 
   if (network_stopped_ || connections_.empty()) {
     delete packet;
     return;
   }
 
@@ skipping 23 matching lines @@
 
   if (network_stopped_)
     return;
 
   capture_loop_->PostTask(
       FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoFinishOneRecording));
 }
 
 void ScreenRecorder::DoAddConnection(
     scoped_refptr<ConnectionToClient> connection) {
-  DCHECK_EQ(network_loop_, MessageLoop::current());
+  DCHECK(network_loop_->BelongsToCurrentThread());
 
   connections_.push_back(connection);
 }
 
 void ScreenRecorder::DoRemoveClient(
     scoped_refptr<ConnectionToClient> connection) {
-  DCHECK_EQ(network_loop_, MessageLoop::current());
+  DCHECK(network_loop_->BelongsToCurrentThread());
 
   ConnectionToClientList::iterator it =
       std::find(connections_.begin(), connections_.end(), connection);
   if (it != connections_.end()) {
     connections_.erase(it);
   }
 }
 
 void ScreenRecorder::DoRemoveAllClients() {
-  DCHECK_EQ(network_loop_, MessageLoop::current());
+  DCHECK(network_loop_->BelongsToCurrentThread());
 
   // Clear the list of connections.
   connections_.clear();
 }
 
 void ScreenRecorder::DoStopOnNetworkThread(Task* done_task) {
-  DCHECK_EQ(network_loop_, MessageLoop::current());
+  DCHECK(network_loop_->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
   // thread.
   //
   // After that a task is posted on encode thread to continue the stop
   // sequence.
   network_stopped_ = true;
 
   encode_loop_->PostTask(
@@ skipping 53 matching lines @@
         (base::Time::Now() - encode_start_time_).InMilliseconds());
     packet->set_encode_time_ms(encode_time);
   }
 
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &ScreenRecorder::DoSendVideoPacket, packet));
 }
 
 }  // namespace remoting