Don't use barcodes in ProtocolPerfTests

remoting/host/chromoting_host_unittest.cc

 // Copyright (c) 2012 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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 118 matching lines @@
     protocol::ConnectionToClient* connection_ptr = connection.get();
     std::unique_ptr<ClientSession> client(new ClientSession(
         host_.get(), std::move(connection), desktop_environment_factory_.get(),
         base::TimeDelta(), nullptr, std::vector<HostExtension*>()));
     ClientSession* client_ptr = client.get();
 
     connection_ptr->set_host_stub(client.get());
     get_client(connection_index) = client_ptr;
 
     // |host| is responsible for deleting |client| from now on.
-    host_->clients_.push_back(client.release());
+    host_->clients_.push_back(std::move(client));
 
     if (authenticate) {
       client_ptr->OnConnectionAuthenticated();
       if (!reject)
         client_ptr->OnConnectionChannelsConnected();
     } else {
       client_ptr->OnConnectionClosed(protocol::AUTHENTICATION_FAILED);
     }
   }
 
@@ skipping 87 matching lines @@
 
   protocol::FakeConnectionToClient*& get_connection(int connection_index) {
     return (connection_index == 0) ? connection1_ : connection2_;
   }
 
   // Returns the cached client pointers client1_ or client2_.
   ClientSession*& get_client(int connection_index) {
     return (connection_index == 0) ? client1_ : client2_;
   }
 
-  // Returns the list of clients of the host_.
-  std::list<ClientSession*>& get_clients_from_host() {
-    return host_->clients_;
-  }
-
   const std::string& get_session_jid(int connection_index) {
     return (connection_index == 0) ? session_jid1_ : session_jid2_;
   }
 };
 
 TEST_F(ChromotingHostTest, StartAndShutdown) {
   StartHost();
 }
 
 TEST_F(ChromotingHostTest, Connect) {
@@ skipping 69 matching lines @@
   StartHost();
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
 
   EXPECT_CALL(*session_unowned1_, Close(_)).WillOnce(
     InvokeWithoutArgs(this, &ChromotingHostTest::NotifyConnectionClosed1));
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
-  host_->OnSessionAuthenticating(get_clients_from_host().front());
+  host_->OnSessionAuthenticating(
+      host_->client_sessions_for_tests().front().get());
   host_->OnIncomingSession(session_unowned2_.get(), &response);
   EXPECT_EQ(protocol::SessionManager::OVERLOAD, response);
 }
 
 TEST_F(ChromotingHostTest, LoginBackOffUponAuthenticating) {
   StartHost();
 
   EXPECT_CALL(*session_unowned1_, Close(_)).WillOnce(
     InvokeWithoutArgs(this, &ChromotingHostTest::NotifyConnectionClosed1));
 
   EXPECT_CALL(*session_unowned2_, Close(_)).WillOnce(
     InvokeWithoutArgs(this, &ChromotingHostTest::NotifyConnectionClosed2));
 
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::DECLINE;
 
   host_->OnIncomingSession(session_unowned1_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   host_->OnIncomingSession(session_unowned2_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   // This will set the backoff.
-  host_->OnSessionAuthenticating(get_clients_from_host().front());
+  host_->OnSessionAuthenticating(
+      host_->client_sessions_for_tests().front().get());
 
   // This should disconnect client2.
-  host_->OnSessionAuthenticating(get_clients_from_host().back());
+  host_->OnSessionAuthenticating(
+      host_->client_sessions_for_tests().back().get());
 
   // Verify that the host only has 1 client at this point.
-  EXPECT_EQ(get_clients_from_host().size(), 1U);
+  EXPECT_EQ(host_->client_sessions_for_tests().size(), 1U);
 }
 
 TEST_F(ChromotingHostTest, OnSessionRouteChange) {
   StartHost();
 
 
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   std::string channel_name("ChannelName");
   protocol::TransportRoute route;
   EXPECT_CALL(host_status_observer_,
               OnClientRouteChange(session_jid1_, channel_name, _));
   host_->OnSessionRouteChange(get_client(0), channel_name, route);
 }
 
 TEST_F(ChromotingHostTest, DisconnectAllClients) {
   StartHost();
 
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   ExpectClientDisconnected(0);
   DisconnectAllClients();
   testing::Mock::VerifyAndClearExpectations(&host_status_observer_);
 }
 
 }  // namespace remoting