Add VideoReader and VideoWriter interfaces.

remoting/client/jingle_host_connection.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 "base/callback.h"
 #include "base/message_loop.h"
 #include "remoting/base/constants.h"
 // TODO(hclam): Remove this header once MessageDispatcher is used.
 #include "remoting/base/multiple_array_input_stream.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/jingle_host_connection.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/protocol/jingle_chromotocol_server.h"
+#include "remoting/protocol/video_stub.h"
 #include "remoting/protocol/util.h"
 
 namespace remoting {
 
 JingleHostConnection::JingleHostConnection(ClientContext* context)
     : context_(context),
       event_callback_(NULL) {
 }
 
 JingleHostConnection::~JingleHostConnection() {
 }
 
 void JingleHostConnection::Connect(const ClientConfig& config,
-                                   HostEventCallback* event_callback) {
+                                   HostEventCallback* event_callback,
+                                   VideoStub* video_stub) {
   event_callback_ = event_callback;
+  video_stub_ = video_stub;
 
   // Initialize |jingle_client_|.
   jingle_client_ = new JingleClient(context_->jingle_thread());
   jingle_client_->Init(config.username, config.auth_token,
                        kChromotingTokenServiceName, this);
 
   // Save jid of the host. The actual connection is created later after
   // |jingle_client_| is connected.
   host_jid_ = config.host_jid;
 }
 
 void JingleHostConnection::Disconnect() {
   if (MessageLoop::current() != message_loop()) {
     message_loop()->PostTask(
         FROM_HERE, NewRunnableMethod(this,
                                      &JingleHostConnection::Disconnect));
     return;
   }
 
+  control_reader_.Close();
   event_writer_.Close();
-  video_reader_.Close();
+  video_reader_->Close();
 
   if (connection_) {
     connection_->Close(
         NewRunnableMethod(this, &JingleHostConnection::OnDisconnected));
   } else {
     OnDisconnected();
   }
 }
 
-void JingleHostConnection::OnVideoMessage(
-    ChromotingHostMessage* msg) {
+void JingleHostConnection::OnControlMessage(ChromotingHostMessage* msg) {
   event_callback_->HandleMessage(this, msg);
 }
 
 void JingleHostConnection::InitConnection() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
 
   // Initialize |chromotocol_server_|.
   JingleChromotocolServer* chromotocol_server =
       new JingleChromotocolServer(context_->jingle_thread());
   // TODO(ajwong): Make this a command switch when we're more stable.
@@ skipping 72 matching lines @@
     case ChromotocolConnection::FAILED:
       event_callback_->OnConnectionFailed(this);
       break;
 
     case ChromotocolConnection::CLOSED:
       event_callback_->OnConnectionClosed(this);
       break;
 
     case ChromotocolConnection::CONNECTED:
       // Initialize reader and writer.
+      control_reader_.Init<ChromotingHostMessage>(
+          connection_->control_channel(),
+          NewCallback(this, &JingleHostConnection::OnControlMessage));
       event_writer_.Init(connection_->event_channel());
-      video_reader_.Init<ChromotingHostMessage>(
-          connection_->video_channel(),
-          NewCallback(this, &JingleHostConnection::OnVideoMessage));
+      video_reader_.reset(VideoReader::Create(connection_->config()));
+      video_reader_->Init(connection_, video_stub_);
       event_callback_->OnConnectionOpened(this);
       break;
 
     default:
       // Ignore the other states by default.
       break;
   }
 }
 
 MessageLoop* JingleHostConnection::message_loop() {
   return context_->jingle_thread()->message_loop();
 }
 
 }  // namespace remoting