Implement a chromoting client using X11

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/stl_util-inl.h"
@@ skipping 31 matching lines @@
       network_loop_(network_loop),
       capturer_(capturer),
       encoder_(encoder),
       rate_(kDefaultCaptureRate),
       max_rate_(kDefaultCaptureRate),
       started_(false),
       recordings_(0),
       rate_control_started_(false),
       capture_width_(0),
       capture_height_(0),
-      capture_pixel_format_(chromotocol_pb::PixelFormatInvalid),
+      capture_pixel_format_(PixelFormatInvalid),
       encode_stream_started_(false),
       encode_done_(false) {
   DCHECK(capture_loop_);
   DCHECK(encode_loop_);
   DCHECK(network_loop_);
 }
 
 SessionManager::~SessionManager() {
   clients_.clear();
-  DCHECK_EQ(0u, clients_.size());
 }
 
 void SessionManager::Start() {
   capture_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManager::DoStart));
 }
 
 void SessionManager::DoStart() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
@@ skipping 52 matching lines @@
   }
   rate_control_started_ = false;
 }
 
 void SessionManager::SetMaxRate(double rate) {
   capture_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManager::DoSetMaxRate, rate));
 }
 
 void SessionManager::AddClient(scoped_refptr<ClientConnection> client) {
-  network_loop_->PostTask(
+  // Gets the init information for the client.
+  capture_loop_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &SessionManager::DoAddClient, client));
+      NewRunnableMethod(this, &SessionManager::DoGetInitInfo, client));
 }
 
 void SessionManager::RemoveClient(scoped_refptr<ClientConnection> client) {
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoRemoveClient, client));
 }
 
 void SessionManager::DoCapture() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
@@ skipping 59 matching lines @@
       capture_data_,
       capture_data_strides_,
       false,
       &encoded_data_header_,
       &encoded_data_,
       &encode_done_,
       NewRunnableMethod(this, &SessionManager::EncodeDataAvailableTask));
 }
 
 void SessionManager::DoSendUpdate(
-    chromotocol_pb::UpdateStreamPacketHeader* header,
+    UpdateStreamPacketHeader* header,
     scoped_refptr<media::DataBuffer> encoded_data,
     bool begin_update, bool end_update) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   for (size_t i = 0; i < clients_.size(); ++i) {
     if (begin_update)
       clients_[i]->SendBeginUpdateStreamMessage();
 
     // This will pass the ownership of the DataBuffer to the ClientConnection.
     clients_[i]->SendUpdateStreamPacketMessage(header, encoded_data);
 
     if (end_update)
       clients_[i]->SendEndUpdateStreamMessage();
   }
 }
 
 void SessionManager::DoSendInit(scoped_refptr<ClientConnection> client,
                                 int width, int height) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // Sends the client init information.
   client->SendInitClientMessage(width, height);
 }
 
 void SessionManager::DoGetInitInfo(scoped_refptr<ClientConnection> client) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
+  // Sends the init message to the cleint.
   network_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManager::DoSendInit, client,
                         capturer_->GetWidth(), capturer_->GetHeight()));
+
+  // And then add the client to the list so it can receive update stream.
+  // It is important we do so in such order or the client will receive
+  // update stream before init message.
+  network_loop_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &SessionManager::DoAddClient, client));
 }
 
 void SessionManager::DoSetRate(double rate) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
   if (rate == rate_)
     return;
 
   // Change the current capture rate.
   rate_ = rate;
 
@@ skipping 13 matching lines @@
   } else {
     NOTREACHED() << "Rate is too small.";
   }
 }
 
 void SessionManager::DoAddClient(scoped_refptr<ClientConnection> client) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // TODO(hclam): Force a full frame for next encode.
   clients_.push_back(client);
-
-  // Gets the init information for the client.
-  capture_loop_->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &SessionManager::DoGetInitInfo, client));
 }
 
 void SessionManager::DoRemoveClient(scoped_refptr<ClientConnection> client) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // TODO(hclam): Is it correct to do to a scoped_refptr?
   ClientConnectionList::iterator it
       = std::find(clients_.begin(), clients_.end(), client);
   if (it != clients_.end())
     clients_.erase(it);
@@ skipping 95 matching lines @@
   // the ClientConnections.
   encoded_data_ = NULL;
 
   if (encode_done_) {
     capture_loop_->PostTask(
         FROM_HERE, NewRunnableMethod(this, &SessionManager::DoFinishEncode));
   }
 }
 
 }  // namespace remoting