Remove authenticated_ fields from stubs.

remoting/host/chromoting_host_unittest.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/host/in_memory_host_config.h"
+#include "remoting/host/user_authenticator_fake.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::remoting::protocol::LocalLoginCredentials;
 using ::remoting::protocol::MockClientStub;
 using ::remoting::protocol::MockConnectionToClient;
@@ skipping 12 matching lines @@
 using testing::DoAll;
 using testing::InSequence;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::Sequence;
 
 namespace remoting {
 
 namespace {
 
+UserAuthenticator* MakeUserAuthenticator() {
+  return new UserAuthenticatorFake();
+}
+
 void PostQuitTask(MessageLoop* message_loop) {
   message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 // Run the task and delete it afterwards. This action is used to deal with
 // done callbacks.
 ACTION(RunDoneTask) {
   arg1->Run();
   delete arg1;
 }
 
 ACTION_P(QuitMainMessageLoop, message_loop) {
   PostQuitTask(message_loop);
 }
 
+void DummyFunction() {}

[Jamie, 2011/03/31 11:31:25]

Can we rename this |DummyDoneTask| or something that better reflects why it's
needed? I had to look at the |BeginSessionRequest| definition to work out what
it was for.

Nit: Other empty function in this file use two lines, not one.

[simonmorris, 2011/03/31 12:23:43]

Done.

+
 }  // namespace
 
 class ChromotingHostTest : public testing::Test {
  public:
   ChromotingHostTest() {
   }
 
   virtual void SetUp() {
     config_ = new InMemoryHostConfig();
     ON_CALL(context_, main_message_loop())
@@ skipping 11 matching lines @@
 
     Capturer* capturer = new CapturerFake();
     host_stub_ = new MockHostStub();
     host_stub2_ = new MockHostStub();
     input_stub_ = new MockInputStub();
     input_stub2_ = new MockInputStub();
     curtain_ = new MockCurtain();
     DesktopEnvironment* desktop =
         new DesktopEnvironment(capturer, input_stub_, curtain_);
     host_ = ChromotingHost::Create(&context_, config_, desktop);
+    credentials_good_.set_type(protocol::PASSWORD);
+    credentials_good_.set_username("user");
+    credentials_good_.set_credential("password");
+    credentials_bad_.set_type(protocol::PASSWORD);
+    credentials_bad_.set_username(UserAuthenticatorFake::fail_username());
+    credentials_bad_.set_credential(UserAuthenticatorFake::fail_password());
     connection_ = new MockConnectionToClient(
         &message_loop_, &handler_, host_stub_, input_stub_);
     connection2_ = new MockConnectionToClient(
         &message_loop_, &handler_, host_stub2_, input_stub2_);
     session_ = new MockSession();
     session2_ = new MockSession();
     session_config_.reset(SessionConfig::CreateDefault());
     session_config2_.reset(SessionConfig::CreateDefault());
 
     ON_CALL(video_stub_, ProcessVideoPacket(_, _))
@@ skipping 36 matching lines @@
         .Times(AnyNumber());
   }
 
   virtual void TearDown() {
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate) {
     scoped_refptr<MockConnectionToClient> connection =
         (connection_index == 0) ? connection_ : connection2_;
-    scoped_refptr<ClientSession> client = new ClientSession(host_.get(),
-                                                            connection);
+    protocol::LocalLoginCredentials& credentials =
+        authenticate ? credentials_good_ : credentials_bad_;
+    scoped_refptr<ClientSession> client = new ClientSession(
+        host_.get(),
+        base::Bind(MakeUserAuthenticator),
+        connection,
+        input_stub_);
     connection->set_host_stub(client.get());
 
     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(host_.get(),
                           &ChromotingHost::AddClient,
                           client));
     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(host_.get(),
                           &ChromotingHost::OnClientConnected,
                           connection));
-    if (authenticate) {
-      context_.network_message_loop()->PostTask(
-          FROM_HERE,
-          NewRunnableMethod(host_.get(),
-                            &ChromotingHost::LocalLoginSucceeded,
-                            connection));
-    } else {
-      context_.network_message_loop()->PostTask(
-          FROM_HERE,
-          NewRunnableMethod(host_.get(),
-                            &ChromotingHost::LocalLoginFailed,
-                            connection));
-    }
+    context_.network_message_loop()->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(client.get(),
+                          &ClientSession::BeginSessionRequest,
+                          &credentials,
+                          NewRunnableFunction(&DummyFunction)));
   }
 
   // Helper method to remove a client connection from ChromotingHost.
   void RemoveClientConnection() {
     context_.network_message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(host_.get(),
                           &ChromotingHost::OnClientDisconnected,
                           connection_));
   }
 
  protected:
   MessageLoop message_loop_;
   MockConnectionToClientEventHandler handler_;
   scoped_refptr<ChromotingHost> host_;
   scoped_refptr<InMemoryHostConfig> config_;
   MockChromotingHostContext context_;
+  protocol::LocalLoginCredentials credentials_good_;
+  protocol::LocalLoginCredentials credentials_bad_;
   scoped_refptr<MockConnectionToClient> connection_;
   scoped_refptr<MockSession> session_;
   scoped_ptr<SessionConfig> session_config_;
   MockVideoStub video_stub_;
   MockClientStub client_stub_;
   MockHostStub* host_stub_;
   MockInputStub* input_stub_;
   MockCurtain* curtain_;
   scoped_refptr<MockConnectionToClient> connection2_;
   scoped_refptr<MockSession> session2_;
@@ skipping 194 matching lines @@
         .Times(AnyNumber());
     EXPECT_CALL(video_stub2_, ProcessVideoPacket(_, _))
         .Times(0);
   }
 
   SimulateClientConnection(0, true);
   message_loop_.Run();
 }
 
 }  // namespace remoting