Pass TransportConfig to TransportFactory instead of Transport.

remoting/protocol/pepper_transport_factory.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/pepper_transport_factory.h"
 
 #include "base/bind.h"
 #include "crypto/hmac.h"
 #include "jingle/glue/utils.h"
 #include "net/base/cert_status_flags.h"
@@ skipping 20 matching lines @@
 const int kTcpAckDelayMilliseconds = 10;
 
 // Values for the TCP send and receive buffer size. This should be tuned to
 // accomodate high latency network but not backlog the decoding pipeline.
 const int kTcpReceiveBufferSize = 256 * 1024;
 const int kTcpSendBufferSize = kTcpReceiveBufferSize + 30 * 1024;
 
 class PepperStreamTransport : public StreamTransport,
                               public PepperTransportSocketAdapter::Observer {
  public:
-  PepperStreamTransport(pp::Instance* pp_instance);
+  PepperStreamTransport(pp::Instance* pp_instance,
+                        const TransportConfig& config);
   virtual ~PepperStreamTransport();
 
   // StreamTransport interface.
   virtual void Initialize(
       const std::string& name,
-      const TransportConfig& config,
       Transport::EventHandler* event_handler,
       scoped_ptr<ChannelAuthenticator> authenticator) OVERRIDE;
   virtual void Connect(
       const StreamTransport::ConnectedCallback& callback) OVERRIDE;
   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE;
   virtual const std::string& name() const OVERRIDE;
   virtual bool is_connected() const OVERRIDE;
 
   // PepperTransportSocketAdapter::Observer interface.
   virtual void OnChannelDeleted() OVERRIDE;
   virtual void OnChannelNewLocalCandidate(
       const std::string& candidate) OVERRIDE;
 
  private:
   void OnP2PConnect(int result);
   void OnAuthenticationDone(net::Error error,
                             scoped_ptr<net::StreamSocket> socket);
 
   void NotifyConnected(scoped_ptr<net::StreamSocket> socket);
   void NotifyConnectFailed();
 
   pp::Instance* pp_instance_;
+  TransportConfig config_;
   std::string name_;
-  TransportConfig config_;
   EventHandler* event_handler_;
   StreamTransport::ConnectedCallback callback_;
   scoped_ptr<ChannelAuthenticator> authenticator_;
 
   // We own |channel_| until it is connected. After that
   // |authenticator_| owns it.
   scoped_ptr<PepperTransportSocketAdapter> owned_channel_;
   PepperTransportSocketAdapter* channel_;
 
   // Indicates that we've finished connecting.
   bool connected_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperStreamTransport);
 };
 
-PepperStreamTransport::PepperStreamTransport(pp::Instance* pp_instance)
+PepperStreamTransport::PepperStreamTransport(pp::Instance* pp_instance,
+                                             const TransportConfig& config)
     : pp_instance_(pp_instance),
+      config_(config),
       event_handler_(NULL),
       channel_(NULL),
       connected_(false) {
 }
 
 PepperStreamTransport::~PepperStreamTransport() {
   DCHECK(event_handler_);
   event_handler_->OnTransportDeleted(this);
   // Channel should be already destroyed if we were connected.
   DCHECK(!connected_ || channel_ == NULL);
 }
 
 void PepperStreamTransport::Initialize(
     const std::string& name,
-    const TransportConfig& config,
     Transport::EventHandler* event_handler,
     scoped_ptr<ChannelAuthenticator> authenticator) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(!name.empty());
   DCHECK(event_handler);
 
   // Can be initialized only once.
   DCHECK(name_.empty());
 
   name_ = name;
-  config_ = config;
   event_handler_ = event_handler;
   authenticator_ = authenticator.Pass();
 }
 
 void PepperStreamTransport::Connect(
     const StreamTransport::ConnectedCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   // Initialize() must be called first.
   DCHECK(!name_.empty());
@@ skipping 147 matching lines @@
 }  // namespace
 
 PepperTransportFactory::PepperTransportFactory(
     pp::Instance* pp_instance)
     : pp_instance_(pp_instance) {
 }
 
 PepperTransportFactory::~PepperTransportFactory() {
 }
 
+void PepperTransportFactory::SetConfig(const TransportConfig& config) {
+  config_ = config;
+}
+
 scoped_ptr<StreamTransport> PepperTransportFactory::CreateStreamTransport() {
-  return scoped_ptr<StreamTransport>(new PepperStreamTransport(pp_instance_));
+  return scoped_ptr<StreamTransport>(
+      new PepperStreamTransport(pp_instance_, config_));
 }
 
 scoped_ptr<DatagramTransport>
 PepperTransportFactory::CreateDatagramTransport() {
   NOTIMPLEMENTED();
   return scoped_ptr<DatagramTransport>(NULL);
 }
 
 }  // namespace protocol
 }  // namespace remoting