Changes client_token to be client_auth_token.

blimp/net/engine_authentication_handler_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/memory/ref_counted.h"
@@ skipping 14 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Eq;
 using testing::Return;
 using testing::SaveArg;
 
 namespace blimp {
 namespace {
-const char client_token[] = "valid token";
+const char client_auth_token[] = "valid token";
 }  // namespace
 
 class EngineAuthenticationHandlerTest : public testing::Test {
  public:
   EngineAuthenticationHandlerTest()
       : runner_(new base::TestMockTimeTaskRunner),
         runner_handle_(runner_),
         auth_handler_(new EngineAuthenticationHandler(&connection_handler_,
-                                                      client_token)),
+                                                      client_auth_token)),
         connection_(new testing::StrictMock<MockBlimpConnection>()) {}
 
   ~EngineAuthenticationHandlerTest() override {}
 
  protected:
   void ExpectOnConnection() {
     EXPECT_CALL(*connection_, AddConnectionErrorObserver(_))
         .WillOnce(SaveArg<0>(&error_observer_));
     EXPECT_CALL(*connection_, SetIncomingMessageProcessor(_))
         .WillOnce(SaveArg<0>(&incoming_message_processor_));
@@ skipping 10 matching lines @@
 
 TEST_F(EngineAuthenticationHandlerTest, AuthenticationSucceeds) {
   ExpectOnConnection();
   EXPECT_CALL(*connection_, RemoveConnectionErrorObserver(_));
   EXPECT_CALL(connection_handler_, HandleConnectionPtr(Eq(connection_.get())));
   auth_handler_->HandleConnection(std::move(connection_));
   EXPECT_NE(nullptr, error_observer_);
   EXPECT_NE(nullptr, incoming_message_processor_);
 
   std::unique_ptr<BlimpMessage> blimp_message =
-      CreateStartConnectionMessage(client_token, kProtocolVersion);
+      CreateStartConnectionMessage(client_auth_token, kProtocolVersion);
   net::TestCompletionCallback process_message_cb;
   incoming_message_processor_->ProcessMessage(std::move(blimp_message),
                                               process_message_cb.callback());
   EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
 }
 
 TEST_F(EngineAuthenticationHandlerTest, ProtocolMismatch) {
   const int kInvalidProtocolVersion = -1;
 
   BlimpMessage end_connection_message;
   MockBlimpMessageProcessor message_processor;
   EXPECT_CALL(message_processor, MockableProcessMessage(_, _))
       .WillOnce(SaveArg<0>(&end_connection_message));
   EXPECT_CALL(*connection_, GetOutgoingMessageProcessor())
       .WillOnce(Return(&message_processor));
 
   ExpectOnConnection();
   auth_handler_->HandleConnection(std::move(connection_));
 
   std::unique_ptr<BlimpMessage> blimp_message =
-      CreateStartConnectionMessage(client_token, kInvalidProtocolVersion);
+      CreateStartConnectionMessage(client_auth_token, kInvalidProtocolVersion);
   net::TestCompletionCallback process_message_cb;
   incoming_message_processor_->ProcessMessage(std::move(blimp_message),
                                               process_message_cb.callback());
   EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
 
   EXPECT_EQ(BlimpMessage::kProtocolControl,
             end_connection_message.feature_case());
   EXPECT_EQ(
       ProtocolControlMessage::kEndConnection,
       end_connection_message.protocol_control().connection_message_case());
@@ skipping 43 matching lines @@
 
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(11));
 }
 
 TEST_F(EngineAuthenticationHandlerTest, AuthHandlerDeletedFirst) {
   ExpectOnConnection();
   auth_handler_->HandleConnection(std::move(connection_));
   auth_handler_.reset();
 
   std::unique_ptr<BlimpMessage> blimp_message =
-      CreateStartConnectionMessage(client_token, kProtocolVersion);
+      CreateStartConnectionMessage(client_auth_token, kProtocolVersion);
   net::TestCompletionCallback process_message_cb;
   incoming_message_processor_->ProcessMessage(std::move(blimp_message),
                                               process_message_cb.callback());
   EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
 }
 
 }  // namespace blimp