Simplify ScreenCapturer interface.

remoting/host/video_scheduler.cc

 // Copyright (c) 2012 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/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 43 matching lines @@
 
   return scheduler;
 }
 
 // Public methods --------------------------------------------------------------
 
 void VideoScheduler::OnCaptureCompleted(
     scoped_refptr<media::ScreenCaptureData> capture_data) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
+  // Do nothing if the scheduler is being stopped.
+  if (!capturer_)
+    return;
+
   if (capture_data) {
     scheduler_.RecordCaptureTime(
         base::TimeDelta::FromMilliseconds(capture_data->capture_time_ms()));
 
     // The best way to get this value is by binding the sequence number to
     // the callback when calling CaptureInvalidRects(). However the callback
     // system doesn't allow this. Reading from the member variable is
     // accurate as long as capture is synchronous as the following statement
     // will obtain the most recent sequence number received.
     capture_data->set_client_sequence_number(sequence_number_);
   }
 
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this, capture_data));
 }
 
 void VideoScheduler::OnCursorShapeChanged(
     scoped_ptr<media::MouseCursorShape> cursor_shape) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
+  // Do nothing if the scheduler is being stopped.
+  if (!capturer_)
+    return;
+
   scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
       new protocol::CursorShapeInfo());
   cursor_proto->set_width(cursor_shape->size.width());
   cursor_proto->set_height(cursor_shape->size.height());
   cursor_proto->set_hotspot_x(cursor_shape->hotspot.x());
   cursor_proto->set_hotspot_y(cursor_shape->hotspot.y());
   cursor_proto->set_data(cursor_shape->data);
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendCursorShape, this,
@@ skipping 76 matching lines @@
 
   capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
 
   // Capture first frame immedately.
   CaptureNextFrame();
 }
 
 void VideoScheduler::StopOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
-  // Stop |capturer_| and clear it to prevent pending tasks from using it.
-  capturer_->Stop();
-
   // |capture_timer_| must be destroyed on the thread on which it is used.
   capture_timer_.reset();
 
   // Schedule deletion of |capturer_| once the encode thread is no longer
   // processing capture data. See http://crbug.com/163641. This also clears
   // |capturer_| pointer to prevent pending tasks from using it.
   // TODO(wez): Make it safe to tear down capturer while buffers remain, and
   // remove this work-around.
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StopOnEncodeThread, this,
@@ skipping 78 matching lines @@
 void VideoScheduler::SendCursorShape(
     scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!cursor_stub_)
     return;
 
   cursor_stub_->SetCursorShape(*cursor_shape);
 }
 
-void VideoScheduler::StopOnNetworkThread(
-    scoped_ptr<media::ScreenCapturer> capturer) {
-  DCHECK(network_task_runner_->BelongsToCurrentThread());
-
-  // This is posted by StopOnEncodeThread meaning that both capture and encode
-  // threads are stopped now and it is safe to delete |capturer|.
-}
-
 // Encoder thread --------------------------------------------------------------
 
 void VideoScheduler::EncodeFrame(
     scoped_refptr<media::ScreenCaptureData> capture_data) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   // If there is nothing to encode then send an empty keep-alive packet.
   if (!capture_data || capture_data->dirty_region().isEmpty()) {
     scoped_ptr<VideoPacket> packet(new VideoPacket());
     packet->set_flags(VideoPacket::LAST_PARTITION);
@@ skipping 21 matching lines @@
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 void VideoScheduler::StopOnEncodeThread(
     scoped_ptr<media::ScreenCapturer> capturer) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   // This is posted by StopOnCaptureThread, so we know that by the time we
-  // process it there are no more encode tasks queued. Pass |capturer_| for
-  // deletion on the thread that created it.
-  network_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoScheduler::StopOnNetworkThread, this,
-                            base::Passed(&capturer)));
+  // process it there are no more encode tasks queued. Pass |capturer| for
+  // deletion on the capture thread.
+  capture_task_runner_->DeleteSoon(FROM_HERE, capturer.release());
 }
 
 }  // namespace remoting