Chromoting: Rename ChromotocolConfig -> SessionConfig

remoting/protocol/jingle_session_manager.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 "remoting/protocol/jingle_session_manager.h"
 
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "third_party/libjingle/source/talk/p2p/base/constants.h"
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using cricket::ContentDescription;
 using cricket::SessionDescription;
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
-
 namespace protocol {
 
 namespace {
 
 const char kDefaultNs[] = "";
 
 const char kChromotingContentName[] = "chromoting";
 
 // Following constants are used to format session description in XML.
 const char kDescriptionTag[] = "description";
@@ skipping 112 matching lines @@
   } else {
     config->codec = ChannelConfig::CODEC_UNDEFINED;
   }
 
   return true;
 }
 
 }  // namespace
 
 ContentDescription::ContentDescription(
-    const CandidateChromotocolConfig* config)
-    : candidate_config_(config) {
+    const CandidateSessionConfig* candidate_config)
+    : candidate_config_(candidate_config) {
 }
 
 ContentDescription::~ContentDescription() { }
 
 JingleSessionManager::JingleSessionManager(
     JingleThread* jingle_thread)
     : jingle_thread_(jingle_thread),
       cricket_session_manager_(NULL),
       allow_local_ips_(false),
       closed_(false) {
@@ skipping 47 matching lines @@
   closed_task->Run();
   delete closed_task;
 }
 
 void JingleSessionManager::set_allow_local_ips(bool allow_local_ips) {
   allow_local_ips_ = allow_local_ips;
 }
 
 scoped_refptr<protocol::Session> JingleSessionManager::Connect(
     const std::string& jid,
-    CandidateChromotocolConfig* chromotocol_config,
+    CandidateSessionConfig* candidate_config,
     protocol::Session::StateChangeCallback* state_change_callback) {
   // Can be called from any thread.
   scoped_refptr<JingleSession> jingle_session(
       new JingleSession(this));
-  jingle_session->set_candidate_config(chromotocol_config);
+  jingle_session->set_candidate_config(candidate_config);
   message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &JingleSessionManager::DoConnect,
                                    jingle_session, jid,
                                    state_change_callback));
   return jingle_session;
 }
 
 void JingleSessionManager::DoConnect(
     scoped_refptr<JingleSession> jingle_session,
     const std::string& jid,
@@ skipping 74 matching lines @@
   IncomingSessionResponse response = protocol::SessionManager::DECLINE;
 
   // Always reject connection if there is no callback.
   if (incoming_session_callback_.get())
     incoming_session_callback_->Run(jingle_session, &response);
 
   switch (response) {
     case protocol::SessionManager::ACCEPT: {
       // Connection must be configured by the callback.
       DCHECK(jingle_session->config());
-      CandidateChromotocolConfig* candidate_config =
-          CandidateChromotocolConfig::CreateFrom(jingle_session->config());
+      CandidateSessionConfig* candidate_config =
+          CandidateSessionConfig::CreateFrom(jingle_session->config());
       cricket_session->Accept(CreateSessionDescription(candidate_config));
       break;
     }
 
     case protocol::SessionManager::INCOMPATIBLE: {
       cricket_session->Reject(cricket::STR_TERMINATE_INCOMPATIBLE_PARAMETERS);
       break;
     }
 
     case protocol::SessionManager::DECLINE: {
       cricket_session->Reject(cricket::STR_TERMINATE_DECLINE);
       break;
     }
 
     default: {
       NOTREACHED();
     }
   }
 }
 
 // Parse content description generated by WriteContent().
 bool JingleSessionManager::ParseContent(
     cricket::SignalingProtocol protocol,
     const XmlElement* element,
     const cricket::ContentDescription** content,
     cricket::ParseError* error) {
   if (element->Name() == QName(kChromotingXmlNamespace, kDescriptionTag)) {
-    scoped_ptr<CandidateChromotocolConfig> config(
-        CandidateChromotocolConfig::CreateEmpty());
+    scoped_ptr<CandidateSessionConfig> config(
+        CandidateSessionConfig::CreateEmpty());
     const XmlElement* child = NULL;
 
     // <control> tags.
     QName control_tag(kChromotingXmlNamespace, kControlTag);
     child = element->FirstNamed(control_tag);
     while (child) {
       ChannelConfig channel_config;
       if (!ParseChannelConfig(child, false, &channel_config))
         return false;
       config->AddControlConfig(channel_config);
@@ skipping 61 matching lines @@
     cricket::SignalingProtocol protocol,
     const cricket::ContentDescription* content,
     XmlElement** elem,
     cricket::WriteError* error) {
   const ContentDescription* desc =
       static_cast<const ContentDescription*>(content);
 
   XmlElement* root = new XmlElement(
       QName(kChromotingXmlNamespace, kDescriptionTag), true);
 
-  const CandidateChromotocolConfig* config = desc->config();
+  const CandidateSessionConfig* config = desc->config();
   std::vector<ChannelConfig>::const_iterator it;
 
   for (it = config->control_configs().begin();
        it != config->control_configs().end(); ++it) {
     root->AddElement(FormatChannelConfig(*it, kControlTag));
   }
 
   for (it = config->event_configs().begin();
        it != config->event_configs().end(); ++it) {
     root->AddElement(FormatChannelConfig(*it, kEventTag));
@@ skipping 12 matching lines @@
   resolution_tag->AddAttr(QName(kDefaultNs, kHeightAttr),
                           base::IntToString(
                               config->initial_resolution().height));
   root->AddElement(resolution_tag);
 
   *elem = root;
   return true;
 }
 
 SessionDescription* JingleSessionManager::CreateSessionDescription(
-    const CandidateChromotocolConfig* config) {
+    const CandidateSessionConfig* config) {
   SessionDescription* desc = new SessionDescription();
   desc->AddContent(JingleSession::kChromotingContentName,
                    kChromotingXmlNamespace,
                    new ContentDescription(config));
   return desc;
 }
 
 }  // namespace protocol
-
 }  // namespace remoting