Chromoting: Rename ChromotocolConfig -> SessionConfig

remoting/protocol/jingle_session_unittest.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 "base/time.h"
 #include "base/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 17 matching lines @@
 
 namespace remoting {
 namespace protocol {
 class JingleSessionTest;
 }  // namespace protocol
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::protocol::JingleSessionTest);
 
 namespace remoting {
-
 namespace protocol {
 
 namespace {
 // Send 100 messages 1024 bytes each. UDP messages are sent with 10ms delay
 // between messages (about 1 second for 100 messages).
 const int kMessageSize = 1024;
 const int kMessages = 100;
 const int kTestDataSize = kMessages * kMessageSize;
 const int kUdpWriteDelayMs = 10;
 }  // namespace
@@ skipping 13 matching lines @@
 class JingleSessionTest : public testing::Test {
  public:
   // Helper method to copy to set value of client_connection_.
   void SetHostSession(Session* session) {
     DCHECK(session);
     host_session_ = session;
     host_session_->SetStateChangeCallback(
         NewCallback(&host_connection_callback_,
                     &MockSessionCallback::OnStateChange));
 
-    session->set_config(ChromotocolConfig::CreateDefault());
+    session->set_config(SessionConfig::CreateDefault());
   }
 
  protected:
   virtual void SetUp() {
     thread_.Start();
   }
 
   virtual void TearDown() {
     CloseSessions();
 
@@ skipping 77 matching lines @@
         .Times(1)
         .WillOnce(InvokeWithoutArgs(&client_connected_event,
                                     &base::WaitableEvent::Signal));
     // Expect that the connection will be closed eventually.
     EXPECT_CALL(client_connection_callback_,
                 OnStateChange(Session::CLOSED))
         .Times(1);
 
     client_session_ = client_server_->Connect(
         SessionManagerPair::kHostJid,
-        CandidateChromotocolConfig::CreateDefault(),
+        CandidateSessionConfig::CreateDefault(),
         NewCallback(&client_connection_callback_,
                     &MockSessionCallback::OnStateChange));
 
     return host_connected_event.TimedWait(base::TimeDelta::FromMilliseconds(
             TestTimeouts::action_max_timeout_ms())) &&
         client_connected_event.TimedWait(base::TimeDelta::FromMilliseconds(
             TestTimeouts::action_max_timeout_ms()));
   }
 
   static void SignalEvent(base::WaitableEvent* event) {
@@ skipping 350 matching lines @@
   EXPECT_CALL(client_connection_callback_,
               OnStateChange(Session::CONNECTING))
       .Times(1);
   EXPECT_CALL(client_connection_callback_,
               OnStateChange(Session::CLOSED))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(&done_event, &base::WaitableEvent::Signal));
 
   client_session_ = client_server_->Connect(
       SessionManagerPair::kHostJid,
-      CandidateChromotocolConfig::CreateDefault(),
+      CandidateSessionConfig::CreateDefault(),
       NewCallback(&client_connection_callback_,
                   &MockSessionCallback::OnStateChange));
 
   ASSERT_TRUE(
       done_event.TimedWait(base::TimeDelta::FromMilliseconds(
           TestTimeouts::action_max_timeout_ms())));
 }
 
 // Verify that we can connect two endpoints.
 TEST_F(JingleSessionTest, Connect) {
@@ skipping 56 matching lines @@
                            client_session_));
   tester->Start(ChannelTesterBase::VIDEO_RTP);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 }  // namespace protocol
-
 }  // namespace remoting