Cleanup channel dispatchers

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"
@@ skipping 166 matching lines @@
     case Session::ACCEPTING:
     case Session::CONNECTED:
     case Session::AUTHENTICATING:
       // Don't care about these events.
       break;
 
     case Session::AUTHENTICATED:
       SetState(AUTHENTICATED, OK);
 
       control_dispatcher_.reset(new ClientControlDispatcher());
-      control_dispatcher_->Init(
-          session_.get(), session_->config().control_config(),
-          base::Bind(&ConnectionToHost::OnChannelInitialized,
-                     base::Unretained(this)));
+      control_dispatcher_->Init(session_.get(),
+                                session_->config().control_config(), 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)));
+      event_dispatcher_->Init(session_.get(), session_->config().event_config(),
+                              this);
 
       video_dispatcher_.reset(
           new ClientVideoDispatcher(monitored_video_stub_.get()));
       video_dispatcher_->Init(session_.get(), session_->config().video_config(),
-                          base::Bind(&ConnectionToHost::OnChannelInitialized,
-                                     base::Unretained(this)));
+                              this);
 
-      audio_reader_ = AudioReader::Create(session_->config());
-      if (audio_reader_.get()) {
+      if (session_->config().is_audio_enabled()) {
+        audio_reader_.reset(new AudioReader(audio_stub_));
         audio_reader_->Init(session_.get(), session_->config().audio_config(),
-                            base::Bind(&ConnectionToHost::OnChannelInitialized,
-                                       base::Unretained(this)));
-        audio_reader_->set_audio_stub(audio_stub_);
+                            this);
       }
       break;
 
     case Session::CLOSED:
       CloseChannels();
       SetState(CLOSED, OK);
       break;
 
     case Session::FAILED:
       // If we were connected then treat signaling timeout error as if
@@ skipping 12 matching lines @@
       }
       break;
   }
 }
 
 void ConnectionToHost::OnSessionRouteChange(const std::string& channel_name,
                                             const TransportRoute& route) {
   event_callback_->OnRouteChanged(channel_name, route);
 }
 
+void ConnectionToHost::OnChannelInitialized(
+    ChannelDispatcherBase* channel_dispatcher) {
+  NotifyIfChannelsReady();
+}
+
+void ConnectionToHost::OnChannelError(
+    ChannelDispatcherBase* channel_dispatcher,
+    ErrorCode error) {
+  LOG(ERROR) << "Failed to connect channel " << channel_dispatcher;
+  CloseOnError(CHANNEL_CONNECTION_ERROR);
+  return;
+}
+
 void ConnectionToHost::OnVideoChannelStatus(bool active) {
   event_callback_->OnConnectionReady(active);
 }
 
 ConnectionToHost::State ConnectionToHost::state() const {
   return state_;
 }
 
-void ConnectionToHost::OnChannelInitialized(bool successful) {
-  if (!successful) {
-    LOG(ERROR) << "Failed to connect video channel";
-    CloseOnError(CHANNEL_CONNECTION_ERROR);
-    return;
-  }
-
-  NotifyIfChannelsReady();
-}
-
 void ConnectionToHost::NotifyIfChannelsReady() {
   if (!control_dispatcher_.get() || !control_dispatcher_->is_connected())
     return;
   if (!event_dispatcher_.get() || !event_dispatcher_->is_connected())
     return;
   if (!video_dispatcher_.get() || !video_dispatcher_->is_connected())
     return;
   if ((!audio_reader_.get() || !audio_reader_->is_connected()) &&
       session_->config().is_audio_enabled()) {
     return;
@@ skipping 28 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting