Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.
Also includes various cleanups. E.g. main_thread was renamed to capture_thread to reflect what the thread is used for.
Review URL: https://chromiumcodereview.appspot.com/10572005
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@145227 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/remoting/host/screen_recorder.cc b/remoting/host/screen_recorder.cc
index e7b414c9..20b305a9 100644
--- a/remoting/host/screen_recorder.cc
+++ b/remoting/host/screen_recorder.cc
@@ -32,14 +32,14 @@
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 @@
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 @@
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::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 @@
}
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::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::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::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 @@
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::DoInvalidateFullScreen() {
- DCHECK_EQ(capture_loop_, MessageLoop::current());
+ DCHECK(capture_task_runner_->BelongsToCurrentThread());
capturer_->InvalidateFullScreen();
}
@@ -255,7 +255,7 @@
// 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::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 @@
// 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::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 @@
// 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::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 @@
scheduler_.RecordEncodeTime(encode_time);
}
- network_loop_->PostTask(
+ network_task_runner_->PostTask(
FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
base::Passed(packet.Pass())));
}
