Create the desktop environment before any of the channel were connected.

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 13 matching lines @@
 #include "remoting/protocol/message_decoder.h"
 #include "remoting/protocol/video_stub.h"
 #include "remoting/protocol/util.h"
 
 namespace remoting {
 
 // 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(
+VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_ptr<media::ScreenCapturer> 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.Pass(), encoder.Pass(), cursor_stub, video_stub);
-  capture_task_runner->PostTask(
-      FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, scheduler));
-
-  return scheduler;
+    protocol::VideoStub* video_stub)
+    : capture_task_runner_(capture_task_runner),
+      encode_task_runner_(encode_task_runner),
+      network_task_runner_(network_task_runner),
+      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) {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  DCHECK(capturer_);
+  DCHECK(encoder_);
+  DCHECK(cursor_stub_);
+  DCHECK(video_stub_);
 }
 
 // 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_)
@@ skipping 29 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::Start() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  capture_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
+}
+
 void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // 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));
 }
 
 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;
   }
 
   if (is_paused_ != pause) {
     is_paused_ = pause;
 
     // Restart captures if we're resuming and there are none scheduled.
-    if (!is_paused_ && !capture_timer_->IsRunning())
+    if (!is_paused_ && capture_timer_ && !capture_timer_->IsRunning())
       CaptureNextFrame();
   }
 }
 
 void VideoScheduler::UpdateSequenceNumber(int64 sequence_number) {
   if (!capture_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::UpdateSequenceNumber,
                               this, sequence_number));
     return;
   }
 
   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,
-    scoped_ptr<media::ScreenCapturer> 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.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) {
-}
-
 VideoScheduler::~VideoScheduler() {
 }
 
 // Capturer thread -------------------------------------------------------------
 
 void VideoScheduler::StartOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(!capture_timer_);
 
   // Start the capturer and let it notify us if cursor shape changes.
   capturer_->Start(this);
 
   capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
 
   // Capture first frame immedately.
   CaptureNextFrame();
 }
 
@@ skipping 138 matching lines @@
     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 capture thread.
   capture_task_runner_->DeleteSoon(FROM_HERE, capturer.release());
 }
 
 }  // namespace remoting