Chromoting: Rename ChromotocolConfig -> SessionConfig

remoting/protocol/protocol_test_client.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 "build/build_config.h"
 
 #if !defined(OS_WIN)
 extern "C" {
 #include <unistd.h>
 }
@@ skipping 11 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/jingle_client.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/protocol/jingle_session_manager.h"
 
 using remoting::kChromotingTokenServiceName;
 
 namespace remoting {
-
 namespace protocol {
 
 namespace {
 const int kBufferSize = 4096;
 }  // namespace
 
 class ProtocolTestClient;
 
 class ProtocolTestConnection
     : public base::RefCountedThreadSafe<ProtocolTestConnection> {
@@ skipping 236 matching lines @@
 
     session_manager_->Init(
         client_->GetFullJid(), client_->session_manager(),
         NewCallback(this, &ProtocolTestClient::OnNewSession));
     session_manager_->set_allow_local_ips(true);
 
     if (host_jid_ != "") {
       ProtocolTestConnection* connection =
           new ProtocolTestConnection(this, client_->message_loop());
       connection->Init(session_manager_->Connect(
-          host_jid_, CandidateChromotocolConfig::CreateDefault(),
+          host_jid_, CandidateSessionConfig::CreateDefault(),
           NewCallback(connection,
                       &ProtocolTestConnection::OnStateChange)));
       connections_.push_back(make_scoped_refptr(connection));
     }
   } else if (state == JingleClient::CLOSED) {
     std::cerr << "Connection closed" << std::endl;
   }
 }
 
 void ProtocolTestClient::OnNewSession(
     Session* session,
     SessionManager::IncomingSessionResponse* response) {
   std::cerr << "Accepting connection from " << session->jid() << std::endl;
 
-  session->set_config(ChromotocolConfig::CreateDefault());
+  session->set_config(SessionConfig::CreateDefault());
   *response = SessionManager::ACCEPT;
 
   ProtocolTestConnection* test_connection =
       new ProtocolTestConnection(this, client_->message_loop());
   session->SetStateChangeCallback(
       NewCallback(test_connection, &ProtocolTestConnection::OnStateChange));
   test_connection->Init(session);
   AutoLock auto_lock(connections_lock_);
   connections_.push_back(make_scoped_refptr(test_connection));
 }
 
 void ProtocolTestClient::OnFinishedClosing() {
   closed_event_.Signal();
 }
 
 void ProtocolTestClient::DestroyConnection(
     scoped_refptr<ProtocolTestConnection> connection) {
   connection->Close();
   AutoLock auto_lock(connections_lock_);
   for (ConnectionsList::iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     if ((*it) == connection) {
       connections_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace protocol
-
 }  // namespace remoting
 
 using remoting::protocol::ProtocolTestClient;
 
 void usage(char* command) {
   std::cerr << "Usage: " << command << "--username=<username>" << std::endl
             << "\t--auth_token=<auth_token>" << std::endl
             << "\t[--host_jid=<host_jid>]" << std::endl;
   exit(1);
 }
@@ skipping 19 matching lines @@
   if (!cmd_line->HasSwitch("auth_token"))
     usage(argv[0]);
   std::string auth_token(cmd_line->GetSwitchValueASCII("auth_token"));
 
   scoped_refptr<ProtocolTestClient> client(new ProtocolTestClient());
 
   client->Run(username, auth_token, host_jid);
 
   return 0;
 }