Properly handle screen recorder shutdown in ChromotingHost.

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/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.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"
@@ skipping 41 matching lines @@
 ScreenRecorder::~ScreenRecorder() {
 }
 
 // Public methods --------------------------------------------------------------
 
 void ScreenRecorder::Start() {
   capture_loop_->PostTask(
       FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoStart));
 }
 
-void ScreenRecorder::Stop(Task* done_task) {
-  capture_loop_->PostTask(
-      FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoStop, done_task));
+void ScreenRecorder::Stop(const base::Closure& done_task) {
+  if (MessageLoop::current() != capture_loop_) {
+    capture_loop_->PostTask(FROM_HERE, base::Bind(
+        &ScreenRecorder::Stop, this, done_task));
+    return;
+  }
+
+  DCHECK(!done_task.is_null());
+
+  capture_timer_.Stop();
+  is_recording_ = false;
+
+  network_loop_->PostTask(FROM_HERE, base::Bind(
+      &ScreenRecorder::DoStopOnNetworkThread, this, done_task));
 }
 
 void ScreenRecorder::SetMaxRate(double rate) {
   capture_loop_->PostTask(
       FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoSetMaxRate, rate));
 }
 
 void ScreenRecorder::AddConnection(
     scoped_refptr<ConnectionToClient> connection) {
   ScopedTracer tracer("AddConnection");
@@ skipping 58 matching lines @@
     return;
   }
 
   is_recording_ = true;
   StartCaptureTimer();
 
   // Capture first frame immedately.
   DoCapture();
 }
 
-void ScreenRecorder::DoStop(Task* done_task) {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
-
-  base::ScopedTaskRunner done_runner(done_task);
-
-  // We might have not started when we receive a stop command, simply run the
-  // task and then return.
-  if (!is_recording_)
-    return;
-
-  capture_timer_.Stop();
-  is_recording_ = false;
-
-  DCHECK_GE(recordings_, 0);
-  if (recordings_) {
-    network_loop_->PostTask(
-        FROM_HERE,
-        NewTracedMethod(this,
-                        &ScreenRecorder::DoStopOnNetworkThread,
-                        done_runner.Release()));
-    return;
-  }
-}
-
 void ScreenRecorder::DoSetMaxRate(double max_rate) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   // TODO(hclam): Should also check for small epsilon.
   DCHECK_GT(max_rate, 0.0) << "Rate is too small.";
 
   max_rate_ = max_rate;
 
   // Restart the timer with the new rate.
   if (is_recording_) {
@@ skipping 149 matching lines @@
   }
 }
 
 void ScreenRecorder::DoRemoveAllClients() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // Clear the list of connections.
   connections_.clear();
 }
 
-void ScreenRecorder::DoStopOnNetworkThread(Task* done_task) {
+void ScreenRecorder::DoStopOnNetworkThread(const base::Closure& done_task) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // 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;
 
@@ skipping 23 matching lines @@
   }
 
   TraceContext::tracer()->PrintString("Encode start");
   encode_start_time_ = base::Time::Now();
   encoder()->Encode(
       capture_data, false,
       NewCallback(this, &ScreenRecorder::EncodedDataAvailableCallback));
   TraceContext::tracer()->PrintString("Encode Done");
 }
 
-void ScreenRecorder::DoStopOnEncodeThread(Task* done_task) {
+void ScreenRecorder::DoStopOnEncodeThread(const base::Closure& done_task) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   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.
-  if (done_task)
-    capture_loop_->PostTask(FROM_HERE, done_task);
+  capture_loop_->PostTask(FROM_HERE, done_task);
 }
 
 void ScreenRecorder::EncodedDataAvailableCallback(VideoPacket* packet) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   if (encoder_stopped_)
     return;
 
   bool last = (packet->flags() & VideoPacket::LAST_PACKET) != 0;
   if (last) {
     int encode_time = static_cast<int>(
         (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