Rename classes for Chromoting:

remoting/host/chromoting_host.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/host/chromoting_host.h"
 
 #include "base/stl_util-inl.h"
 #include "base/task.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_verbatim.h"
 #include "remoting/base/encoder_vp8.h"
 #include "remoting/base/encoder_zlib.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/capturer.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/session_manager.h"
-#include "remoting/protocol/jingle_chromotocol_server.h"
 #include "remoting/protocol/chromotocol_config.h"
+#include "remoting/protocol/jingle_session_manager.h"
 
 namespace remoting {
 
 ChromotingHost::ChromotingHost(ChromotingHostContext* context,
                                MutableHostConfig* config,
                                Capturer* capturer,
                                EventExecutor* executor)
     : context_(context),
       config_(config),
       capturer_(capturer),
@@ skipping 77 matching lines @@
   // Disconnect all clients.
   if (client_) {
     client_->Disconnect();
   }
 
   // Stop the heartbeat sender.
   if (heartbeat_sender_) {
     heartbeat_sender_->Stop();
   }
 
-  // Stop chromotocol server.
-  if (chromotocol_server_) {
-    chromotocol_server_->Close(
+  // Stop chromotocol session manager.
+  if (session_manager_) {
+    session_manager_->Close(
         NewRunnableMethod(this, &ChromotingHost::OnServerClosed));
   }
 
   // Disconnect from the talk network.
   if (jingle_client_) {
     jingle_client_->Close();
   }
 
   // Lastly call the shutdown task.
   if (shutdown_task_.get()) {
     shutdown_task_->Run();
   }
 }
 
 // This method is called if a client is connected to this object.
 void ChromotingHost::OnClientConnected(ClientConnection* client) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
   // Create a new RecordSession if there was none.
   if (!session_.get()) {
     // Then we create a SessionManager passing the message loops that
     // it should run on.
     DCHECK(capturer_.get());
 
-    Encoder* encoder = CreateEncoder(client->connection()->config());
+    Encoder* encoder = CreateEncoder(client->session()->config());
 
     session_ = new SessionManager(context_->capture_message_loop(),
                                   context_->encode_message_loop(),
                                   context_->main_message_loop(),
                                   capturer_.release(),
                                   encoder);
   }
 
   // Immediately add the client and start the session.
   session_->AddClient(client);
@@ skipping 53 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // JingleClient::Callback implementations
 void ChromotingHost::OnStateChange(JingleClient* jingle_client,
                                    JingleClient::State state) {
   if (state == JingleClient::CONNECTED) {
     DCHECK_EQ(jingle_client_.get(), jingle_client);
     VLOG(1) << "Host connected as " << jingle_client->GetFullJid();
 
-    // Create and start |chromotocol_server_|.
-    JingleChromotocolServer* server =
-        new JingleChromotocolServer(context_->jingle_thread());
+    // Create and start session manager.
+    protocol::JingleSessionManager* server =
+        new protocol::JingleSessionManager(context_->jingle_thread());
     // TODO(ajwong): Make this a command switch when we're more stable.
     server->set_allow_local_ips(true);
     server->Init(jingle_client->GetFullJid(),
                  jingle_client->session_manager(),
-                 NewCallback(this, &ChromotingHost::OnNewClientConnection));
-    chromotocol_server_ = server;
+                 NewCallback(this, &ChromotingHost::OnNewClientSession));
+    session_manager_ = server;
 
     // Start heartbeating.
     heartbeat_sender_->Start();
   } else if (state == JingleClient::CLOSED) {
     VLOG(1) << "Host disconnected from talk network.";
 
     // Stop heartbeating.
     heartbeat_sender_->Stop();
 
     // TODO(sergeyu): We should try reconnecting here instead of terminating
     // the host.
     Shutdown();
   }
 }
 
-void ChromotingHost::OnNewClientConnection(
-    ChromotocolConnection* connection,
-    ChromotocolServer::IncomingConnectionResponse* response) {
+void ChromotingHost::OnNewClientSession(
+    protocol::Session* session,
+    protocol::SessionManager::IncomingSessionResponse* response) {
   AutoLock auto_lock(lock_);
   // TODO(hclam): Allow multiple clients to connect to the host.
   if (client_.get() || state_ != kStarted) {
-    *response = ChromotocolServer::DECLINE;
+    *response = protocol::SessionManager::DECLINE;
     return;
   }
 
   // Check that the user has access to the host.
-  if (!access_verifier_.VerifyPermissions(connection->jid())) {
-    *response = ChromotocolServer::DECLINE;
+  if (!access_verifier_.VerifyPermissions(session->jid())) {
+    *response = protocol::SessionManager::DECLINE;
     return;
   }
 
   scoped_ptr<CandidateChromotocolConfig> local_config(
       CandidateChromotocolConfig::CreateDefault());
   local_config->SetInitialResolution(
       ScreenResolution(capturer_->width(), capturer_->height()));
   // TODO(sergeyu): Respect resolution requested by the client if supported.
   ChromotocolConfig* config =
-      local_config->Select(connection->candidate_config(),
+      local_config->Select(session->candidate_config(),
                            true /* force_host_resolution */);
 
   if (!config) {
-    LOG(WARNING) << "Rejecting connection from " << connection->jid()
-                 << " because no compartible configuration has been found.";
-    *response = ChromotocolServer::INCOMPATIBLE;
+    LOG(WARNING) << "Rejecting connection from " << session->jid()
+                 << " because no compatible configuration has been found.";
+    *response = protocol::SessionManager::INCOMPATIBLE;
     return;
   }
 
-  connection->set_config(config);
+  session->set_config(config);
 
-  *response = ChromotocolServer::ACCEPT;
+  *response = protocol::SessionManager::ACCEPT;
 
-  VLOG(1) << "Client connected: " << connection->jid();
+  VLOG(1) << "Client connected: " << session->jid();
 
   // If we accept the connected then create a client object and set the
   // callback.
   client_ = new ClientConnection(context_->main_message_loop(), this);
-  client_->Init(connection);
+  client_->Init(session);
 }
 
 void ChromotingHost::OnServerClosed() {
   // Don't need to do anything here.
 }
 
 // TODO(sergeyu): Move this to SessionManager?
 Encoder* ChromotingHost::CreateEncoder(const ChromotocolConfig* config) {
   const ChannelConfig& video_config = config->video_config();
 
   if (video_config.codec == ChannelConfig::CODEC_VERBATIM) {
     return new remoting::EncoderVerbatim();
   } else if (video_config.codec == ChannelConfig::CODEC_ZIP) {
     return new remoting::EncoderZlib();
   }
   // TODO(sergeyu): Enable VP8 on ARM builds.
 #if !defined(ARCH_CPU_ARM_FAMILY)
   else if (video_config.codec == ChannelConfig::CODEC_VP8) {
     return new remoting::EncoderVp8();
   }
 #endif
 
   return NULL;
 }
 
 
 }  // namespace remoting