Simplify ConnectionToHost interface.

remoting/protocol/connection_to_host_impl.cc

 // Copyright 2015 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_impl.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/ice_transport.h"
-#include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/transport.h"
-#include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_stub.h"
 
 namespace remoting {
 namespace protocol {
 
-ConnectionToHostImpl::ConnectionToHostImpl()
-    : event_callback_(nullptr),
-      client_stub_(nullptr),
-      clipboard_stub_(nullptr),
-      audio_stub_(nullptr),
-      signal_strategy_(nullptr),
-      state_(INITIALIZING),
-      error_(OK) {}
-
-ConnectionToHostImpl::~ConnectionToHostImpl() {
-  CloseChannels();
-
-  if (session_.get())
-    session_.reset();
-
-  if (session_manager_.get())
-    session_manager_.reset();
-
-  if (signal_strategy_)
-    signal_strategy_->RemoveListener(this);
-}
+ConnectionToHostImpl::ConnectionToHostImpl() {}
+ConnectionToHostImpl::~ConnectionToHostImpl() {}
 
 #define RETURN_STRING_LITERAL(x) \
 case x: \
 return #x;
 
 const char* ConnectionToHost::StateToString(State state) {
   switch (state) {
     RETURN_STRING_LITERAL(INITIALIZING);
     RETURN_STRING_LITERAL(CONNECTING);
     RETURN_STRING_LITERAL(AUTHENTICATED);
     RETURN_STRING_LITERAL(CONNECTED);
     RETURN_STRING_LITERAL(CLOSED);
     RETURN_STRING_LITERAL(FAILED);
   }
   NOTREACHED();
   return nullptr;
 }
 
-void ConnectionToHostImpl::Connect(
-    SignalStrategy* signal_strategy,
-    scoped_refptr<TransportContext> transport_context,
-    scoped_ptr<Authenticator> authenticator,
-    const std::string& host_jid,
-    HostEventCallback* event_callback) {
+void ConnectionToHostImpl::Connect(scoped_ptr<Session> session,
+                                   HostEventCallback* event_callback) {
   DCHECK(client_stub_);
   DCHECK(clipboard_stub_);
   DCHECK(monitored_video_stub_);
 
-  // Initialize default |candidate_config_| if set_candidate_config() wasn't
-  // called.
-  if (!candidate_config_)
-    candidate_config_ = CandidateSessionConfig::CreateDefault();
-  if (!audio_stub_)
-    candidate_config_->DisableAudioChannel();
+  session_ = std::move(session);

[joedow, 2015/12/17 16:59:45]

Why use std::move here instead of passing the scoped_ptr?

[Sergey Ulanov, 2015/12/17 17:32:32]

No good reason. Changed it back to Pass().
I think at some point we will want to replace Pass() with std::move()
everywhere, but it's better to keep the code consistent.

+  session_->SetEventHandler(this);
 
-  signal_strategy_ = signal_strategy;
   event_callback_ = event_callback;
-  authenticator_ = authenticator.Pass();
-
-  // Save jid of the host. The actual connection is created later after
-  // |signal_strategy_| is connected.
-  host_jid_ = host_jid;
-
-  signal_strategy_->AddListener(this);
-
-  session_manager_.reset(new JingleSessionManager(
-      make_scoped_ptr(new IceTransportFactory(transport_context)),
-      signal_strategy));
-  session_manager_->set_protocol_config(candidate_config_->Clone());
 
   SetState(CONNECTING, OK);
-
-  switch (signal_strategy_->GetState()) {
-    case SignalStrategy::CONNECTING:
-      // Nothing to do here. Just need to wait until |signal_strategy_| becomes
-      // connected.
-      break;
-    case SignalStrategy::CONNECTED:
-      StartSession();
-      break;
-    case SignalStrategy::DISCONNECTED:
-      signal_strategy_->Connect();
-      break;
-  }
-}
-
-void ConnectionToHostImpl::set_candidate_config(
-    scoped_ptr<CandidateSessionConfig> config) {
-  DCHECK_EQ(state_, INITIALIZING);
-
-  candidate_config_ = config.Pass();
 }
 
 const SessionConfig& ConnectionToHostImpl::config() {
   return session_->config();
 }
 
 ClipboardStub* ConnectionToHostImpl::clipboard_forwarder() {
   return &clipboard_forwarder_;
 }
 
@@ skipping 20 matching lines @@
       video_stub, base::TimeDelta::FromSeconds(
                       MonitoredVideoStub::kConnectivityCheckDelaySeconds),
       base::Bind(&ConnectionToHostImpl::OnVideoChannelStatus,
                  base::Unretained(this))));
 }
 
 void ConnectionToHostImpl::set_audio_stub(AudioStub* audio_stub) {
   audio_stub_ = audio_stub;
 }
 
-void ConnectionToHostImpl::StartSession() {
-  DCHECK(CalledOnValidThread());
-  DCHECK_EQ(state_, CONNECTING);
-
-  session_ = session_manager_->Connect(host_jid_, authenticator_.Pass());
-  session_->SetEventHandler(this);
-}
-
-void ConnectionToHostImpl::OnSignalStrategyStateChange(
-    SignalStrategy::State state) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(event_callback_);
-
-  if (state == SignalStrategy::CONNECTED) {
-    VLOG(1) << "Connected as: " << signal_strategy_->GetLocalJid();
-    // After signaling has been connected we can try connecting to the host.
-    if (state_ == CONNECTING)
-      StartSession();
-  } else if (state == SignalStrategy::DISCONNECTED) {
-    VLOG(1) << "Connection closed.";
-    CloseOnError(SIGNALING_ERROR);
-  }
-}
-
-bool ConnectionToHostImpl::OnSignalStrategyIncomingStanza(
-    const buzz::XmlElement* stanza) {
-  return false;
-}
-
 void ConnectionToHostImpl::OnSessionStateChange(Session::State state) {
   DCHECK(CalledOnValidThread());
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::INITIALIZING:
     case Session::CONNECTING:
     case Session::ACCEPTING:
     case Session::ACCEPTED:
     case Session::AUTHENTICATING:
@@ skipping 117 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting