Implement InputStub in the host side for chromoting

remoting/host/session_manager.cc

 // Copyright (c) 2010 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/session_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
@@ skipping 21 matching lines @@
 
 // We divide the pending update stream number by this value to determine the
 // rate divider.
 static const int kSlowDownFactor = 10;
 
 // A list of dividers used to divide the max rate to determine the current
 // capture rate.
 static const int kRateDividers[] = {1, 2, 4, 8, 16};
 
 SessionManager::SessionManager(
-    MessageLoop* capture_loop,
+    scoped_refptr<base::MessageLoopProxy> capture_loop,
     MessageLoop* encode_loop,
     MessageLoop* network_loop,
     Capturer* capturer,
     Encoder* encoder)
     : capture_loop_(capture_loop),
       encode_loop_(encode_loop),
       network_loop_(network_loop),
       capturer_(capturer),
       encoder_(encoder),
       rate_(kDefaultCaptureRate),
@@ skipping 44 matching lines @@
 
 void SessionManager::RemoveAllConnections() {
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoRemoveAllClients));
 }
 
 // Private accessors -----------------------------------------------------------
 
 Capturer* SessionManager::capturer() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
   return capturer_.get();
 }
 
 Encoder* SessionManager::encoder() {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
   return encoder_.get();
 }
 
 // Capturer thread -------------------------------------------------------------
 
 void SessionManager::DoStart() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
 
   if (started_) {
     NOTREACHED() << "Record session already started.";
     return;
   }
 
   started_ = true;
   DoCapture();
 
   // Starts the rate regulation.
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoStartRateControl));
 }
 
 void SessionManager::DoPause() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
 
   if (!started_) {
     NOTREACHED() << "Record session not started.";
     return;
   }
 
   started_ = false;
 
   // Pause the rate regulation.
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoPauseRateControl));
 }
 
 void SessionManager::DoSetRate(double rate) {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
   if (rate == rate_)
     return;
 
   // Change the current capture rate.
   rate_ = rate;
 
   // If we have already started then schedule the next capture with the new
   // rate.
   if (started_)
     ScheduleNextCapture();
 }
 
 void SessionManager::DoSetMaxRate(double max_rate) {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): Should also check for small epsilon.
   if (max_rate != 0) {
     max_rate_ = max_rate;
     DoSetRate(max_rate);
   } else {
     NOTREACHED() << "Rate is too small.";
   }
 }
 
 void SessionManager::ScheduleNextCapture() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
 
   ScopedTracer tracer("capture");
 
   TraceContext::tracer()->PrintString("Capture Scheduled");
 
   if (rate_ == 0)
     return;
 
   base::TimeDelta interval = base::TimeDelta::FromMilliseconds(
       static_cast<int>(base::Time::kMillisecondsPerSecond / rate_));
   capture_loop_->PostDelayedTask(
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoCapture),
       interval.InMilliseconds());
 }
 
 void SessionManager::DoCapture() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->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.
   if (recordings_ >= 2 || !started_) {
     return;
   }
   TraceContext::tracer()->PrintString("Capture Started");
 
   base::Time now = base::Time::Now();
   base::TimeDelta interval = base::TimeDelta::FromMilliseconds(
@@ skipping 17 matching lines @@
   DCHECK(capturer());
 
   capturer()->CaptureInvalidRects(
       NewCallback(this, &SessionManager::CaptureDoneCallback));
 }
 
 void SessionManager::CaptureDoneCallback(
     scoped_refptr<CaptureData> capture_data) {
   // TODO(hclam): There is a bug if the capturer doesn't produce any dirty
   // rects.
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
   TraceContext::tracer()->PrintString("Capture Done");
   encode_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoEncode, capture_data));
 }
 
 void SessionManager::DoFinishEncode() {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
 
   // Decrement the number of recording in process since we have completed
   // one cycle.
   --recordings_;
 
   // Try to do a capture again. Note that the following method may do nothing
   // if it is too early to perform a capture.
   if (rate_ > 0)
     DoCapture();
 }
 
 void SessionManager::DoGetInitInfo(
     scoped_refptr<ConnectionToClient> connection) {
-  DCHECK_EQ(capture_loop_, MessageLoop::current());
+  DCHECK(capture_loop_->BelongsToCurrentThread());
 
   ScopedTracer tracer("init");
 
   // Add the client to the list so it can receive update stream.
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoAddClient, connection));
 }
 
 // Network thread --------------------------------------------------------------
@@ skipping 137 matching lines @@
       FROM_HERE,
       NewTracedMethod(this, &SessionManager::DoSendVideoPacket, packet));
 
   if (last) {
     capture_loop_->PostTask(
         FROM_HERE, NewTracedMethod(this, &SessionManager::DoFinishEncode));
   }
 }
 
 }  // namespace remoting