Simplify VideoReader and VideoWriter

remoting/protocol/connection_to_host.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/protocol/connection_to_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/audio_reader.h"
 #include "remoting/protocol/audio_stub.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
+#include "remoting/protocol/client_video_dispatcher.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/transport.h"
-#include "remoting/protocol/video_reader.h"
 #include "remoting/protocol/video_stub.h"
 
 namespace remoting {
 namespace protocol {
 
 ConnectionToHost::ConnectionToHost()
     : event_callback_(NULL),
       client_stub_(NULL),
       clipboard_stub_(NULL),
       audio_stub_(NULL),
@@ skipping 157 matching lines @@
                      base::Unretained(this)));
       control_dispatcher_->set_client_stub(client_stub_);
       control_dispatcher_->set_clipboard_stub(clipboard_stub_);
 
       event_dispatcher_.reset(new ClientEventDispatcher());
       event_dispatcher_->Init(
           session_.get(), session_->config().event_config(),
           base::Bind(&ConnectionToHost::OnChannelInitialized,
                      base::Unretained(this)));
 
-      video_reader_ = VideoReader::Create(session_->config());
-      video_reader_->Init(session_.get(), monitored_video_stub_.get(),
+      video_dispatcher_.reset(new ClientVideoDispatcher());
+      video_dispatcher_->Init(session_.get(), session_->config().video_config(),
                           base::Bind(&ConnectionToHost::OnChannelInitialized,
                                      base::Unretained(this)));
+      video_dispatcher_->set_video_stub(monitored_video_stub_.get());
 
       audio_reader_ = AudioReader::Create(session_->config());
       if (audio_reader_.get()) {
         audio_reader_->Init(session_.get(), session_->config().audio_config(),
                             base::Bind(&ConnectionToHost::OnChannelInitialized,
                                        base::Unretained(this)));
         audio_reader_->set_audio_stub(audio_stub_);
       }
       break;
 
@@ skipping 42 matching lines @@
   }
 
   NotifyIfChannelsReady();
 }
 
 void ConnectionToHost::NotifyIfChannelsReady() {
   if (!control_dispatcher_.get() || !control_dispatcher_->is_connected())
     return;
   if (!event_dispatcher_.get() || !event_dispatcher_->is_connected())
     return;
-  if (!video_reader_.get() || !video_reader_->is_connected())
+  if (!video_dispatcher_.get() || !video_dispatcher_->is_connected())
     return;
   if ((!audio_reader_.get() || !audio_reader_->is_connected()) &&
       session_->config().is_audio_enabled()) {
     return;
   }
   if (state_ != AUTHENTICATED)
     return;
 
   // Start forwarding clipboard and input events.
   clipboard_forwarder_.set_clipboard_stub(control_dispatcher_.get());
   event_forwarder_.set_input_stub(event_dispatcher_.get());
   SetState(CONNECTED, OK);
 }
 
 void ConnectionToHost::CloseOnError(ErrorCode error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void ConnectionToHost::CloseChannels() {
   control_dispatcher_.reset();
   event_dispatcher_.reset();
   clipboard_forwarder_.set_clipboard_stub(NULL);
   event_forwarder_.set_input_stub(NULL);
-  video_reader_.reset();
+  video_dispatcher_.reset();
   audio_reader_.reset();
 }
 
 void ConnectionToHost::SetState(State state, ErrorCode error) {
   DCHECK(CalledOnValidThread());
   // |error| should be specified only when |state| is set to FAILED.
   DCHECK(state == FAILED || error == OK);
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting