Tiny little refactoring of DesktopEnvironment.

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 18 matching lines @@
 
 // Maximum number of frames that can be processed simultaneously.
 // TODO(hclam): Move this value to CaptureScheduler.
 static const int kMaxPendingCaptures = 2;
 
 // static
 scoped_refptr<VideoScheduler> VideoScheduler::Create(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    VideoFrameCapturer* capturer,
+    scoped_ptr<VideoFrameCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub) {
   DCHECK(network_task_runner->BelongsToCurrentThread());
   DCHECK(capturer);
   DCHECK(encoder);
   DCHECK(cursor_stub);
   DCHECK(video_stub);
 
   scoped_refptr<VideoScheduler> scheduler = new VideoScheduler(
       capture_task_runner, encode_task_runner, network_task_runner,
-      capturer, encoder.Pass(), cursor_stub, video_stub);
+      capturer.Pass(), encoder.Pass(), cursor_stub, video_stub);
   capture_task_runner->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, scheduler));
 
   return scheduler;
 }
 
 // Public methods --------------------------------------------------------------
 
 void VideoScheduler::OnCaptureCompleted(
     scoped_refptr<CaptureData> capture_data) {
@@ skipping 25 matching lines @@
   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,
                             base::Passed(&cursor_proto)));
 }
 
-void VideoScheduler::Stop(const base::Closure& done_task) {
+void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-  DCHECK(!done_task.is_null());
 
   // Clear stubs to prevent further updates reaching the client.
   cursor_stub_ = NULL;
   video_stub_ = NULL;
 
   capture_task_runner_->PostTask(FROM_HERE,
-      base::Bind(&VideoScheduler::StopOnCaptureThread, this, done_task));
+      base::Bind(&VideoScheduler::StopOnCaptureThread, this));
 }
 
 void VideoScheduler::Pause(bool pause) {
   if (!capture_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::Pause, this, pause));
     return;
   }
 
@@ skipping 17 matching lines @@
 
   sequence_number_ = sequence_number;
 }
 
 // Private methods -----------------------------------------------------------
 
 VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    VideoFrameCapturer* capturer,
+    scoped_ptr<VideoFrameCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
       network_task_runner_(network_task_runner),
-      capturer_(capturer),
+      capturer_(capturer.Pass()),
       encoder_(encoder.Pass()),
       cursor_stub_(cursor_stub),
       video_stub_(video_stub),
       pending_captures_(0),
       did_skip_frame_(false),
       is_paused_(false),
-      sequence_number_(0) {
+      sequence_number_(0),
+      size_most_recent_(SkISize::Make(0, 0)) {
 }
 
 VideoScheduler::~VideoScheduler() {
 }
 
 // Capturer thread -------------------------------------------------------------
 
 void VideoScheduler::StartOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // Start the capturer and let it notify us of cursor shape changes.
   capturer_->Start(this);
 
   capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
 
   // Capture first frame immedately.
   CaptureNextFrame();
 }
 
-void VideoScheduler::StopOnCaptureThread(const base::Closure& done_task) {
+void VideoScheduler::StopOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // Stop |capturer_| and clear it to prevent pending tasks from using it.
   capturer_->Stop();
-  capturer_ = NULL;
 
   // |capture_timer_| must be destroyed on the thread on which it is used.
   capture_timer_.reset();
 
-  // Ensure that the encode thread is no longer processing capture data,
-  // otherwise tearing down |capturer_| will crash it.  See crbug.com/163641.
+  // 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, done_task));
+  encode_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoScheduler::StopOnEncodeThread, this,
+                            base::Passed(&capturer_)));
 }
 
 void VideoScheduler::ScheduleNextCapture() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   capture_timer_->Start(FROM_HERE,
                         scheduler_.NextCaptureDelay(),
                         this,
                         &VideoScheduler::CaptureNextFrame);
 }
@@ skipping 44 matching lines @@
 void VideoScheduler::SendVideoPacket(scoped_ptr<VideoPacket> packet) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!video_stub_)
     return;
 
   base::Closure callback;
   if ((packet->flags() & VideoPacket::LAST_PARTITION) != 0)
     callback = base::Bind(&VideoScheduler::VideoFrameSentCallback, this);
 
+  // Update saved screen size.
+  if (packet->format().has_screen_width() &&
+      packet->format().has_screen_height()) {
+    size_most_recent_ = SkISize::Make(packet->format().screen_width(),
+                                      packet->format().screen_height());
+  }
+
   video_stub_->ProcessVideoPacket(packet.Pass(), callback);
 }
 
 void VideoScheduler::VideoFrameSentCallback() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!video_stub_)
     return;
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this));
 }
 
 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<VideoFrameCapturer> 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<CaptureData> 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 16 matching lines @@
   if (last) {
     scheduler_.RecordEncodeTime(
         base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   }
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
-void VideoScheduler::StopOnEncodeThread(const base::Closure& done_task) {
+void VideoScheduler::StopOnEncodeThread(
+    scoped_ptr<VideoFrameCapturer> 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.
-  network_task_runner_->PostTask(FROM_HERE, done_task);
+  // process it there are no more encode tasks queued. Schedule deletion of
+  // |capturer_| on the same thread it was created on.
+  network_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoScheduler::StopOnNetworkThread, this,
+                            base::Passed(&capturer)));
 }
 
 }  // namespace remoting