[Chromoting] Request the daemon to open a terminal once a connection has been accepted.

remoting/host/client_session_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 "base/message_loop.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_environment.h"
@@ skipping 14 matching lines @@
 using testing::_;
 using testing::AnyNumber;
 using testing::DeleteArg;
 using testing::Expectation;
 using testing::InSequence;
 using testing::Return;
 using testing::ReturnRef;
 
 class ClientSessionTest : public testing::Test {
  public:
-  ClientSessionTest() {}
+  ClientSessionTest() : event_executor_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     ui_task_runner_ = new AutoThreadTaskRunner(
         message_loop_.message_loop_proxy(),
         base::Bind(&ClientSessionTest::QuitMainMessageLoop,
                    base::Unretained(this)));
 
     EXPECT_CALL(context_, ui_task_runner())
         .Times(AnyNumber())
         .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, capture_task_runner())
         .Times(AnyNumber())
         .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, encode_task_runner())
         .Times(AnyNumber())
         .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, network_task_runner())
         .Times(AnyNumber())
         .WillRepeatedly(Return(ui_task_runner_.get()));
 
     client_jid_ = "user@domain/rest-of-jid";
 
-    event_executor_ = new MockEventExecutor();
-    capturer_ = new MockVideoFrameCapturer();
-    EXPECT_CALL(*capturer_, Start(_));
-    EXPECT_CALL(*capturer_, Stop());
-    EXPECT_CALL(*capturer_, InvalidateRegion(_)).Times(AnyNumber());
-    EXPECT_CALL(*capturer_, CaptureInvalidRegion(_)).Times(AnyNumber());
-
-    scoped_ptr<DesktopEnvironment> desktop_environment(new DesktopEnvironment(
-        scoped_ptr<AudioCapturer>(NULL),
-        scoped_ptr<EventExecutor>(event_executor_),
-        scoped_ptr<VideoFrameCapturer>(capturer_)));
+    desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());

[Wez, 2012/10/17 22:04:24]

nit: Strictly we should use Fakes here, since we're not actually mocking
anything, we just want to fake DE creation for ClientSession.  With them Mocks,
we should keep the |capturer_| member, so that it's possible for a future test
to mock it if we wanted.

[alexeypa (please no reviews), 2012/10/17 22:46:56]

Ack.

+    EXPECT_CALL(*desktop_environment_factory_, CreatePtr(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(Invoke(this,
+                               &ClientSessionTest::CreateDesktopEnvironment));
 
     // Set up a large default screen size that won't affect most tests.
     screen_size_.set(1000, 1000);
-    EXPECT_CALL(*capturer_, size_most_recent())
-        .WillRepeatedly(ReturnRef(screen_size_));
 
     session_config_ = SessionConfig::GetDefault();
 
     protocol::MockSession* session = new MockSession();
     EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(session_config_));
     EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
     EXPECT_CALL(*session, SetEventHandler(_));
     EXPECT_CALL(*session, Close());
     scoped_ptr<protocol::ConnectionToClient> connection(
         new protocol::ConnectionToClient(session));
     connection_ = connection.get();
 
     client_session_ = new ClientSession(
         &session_event_handler_,
         context_.capture_task_runner(),
         context_.encode_task_runner(),
         context_.network_task_runner(),
         connection.Pass(),
-        desktop_environment.Pass(),
+        desktop_environment_factory_.get(),
         base::TimeDelta());
   }
 
   virtual void TearDown() OVERRIDE {
     // MockClientSessionEventHandler won't trigger StopAndDelete, so fake it.
     client_session_->Stop(base::Bind(
         &ClientSessionTest::OnClientStopped, base::Unretained(this)));
 
     // Run message loop before destroying because the session is destroyed
     // asynchronously.
     ui_task_runner_ = NULL;
     message_loop_.Run();
 
     // Verify that the client session has been stopped.
     EXPECT_TRUE(client_session_.get() == NULL);
   }
 
  protected:
+  DesktopEnvironment* CreateDesktopEnvironment(ClientSession* client) {
+    MockVideoFrameCapturer* capturer = new MockVideoFrameCapturer();
+    EXPECT_CALL(*capturer, Start(_));
+    EXPECT_CALL(*capturer, Stop());
+    EXPECT_CALL(*capturer, InvalidateRegion(_)).Times(AnyNumber());
+    EXPECT_CALL(*capturer, CaptureInvalidRegion(_)).Times(AnyNumber());
+    EXPECT_CALL(*capturer, size_most_recent())
+        .WillRepeatedly(ReturnRef(screen_size_));
+
+    EXPECT_TRUE(!event_executor_);
+    event_executor_ = new MockEventExecutor();
+    return new DesktopEnvironment(scoped_ptr<AudioCapturer>(NULL),
+                                  scoped_ptr<EventExecutor>(event_executor_),
+                                  scoped_ptr<VideoFrameCapturer>(capturer));
+  }
+
   void DisconnectClientSession() {
     client_session_->Disconnect();
     // MockSession won't trigger OnConnectionClosed, so fake it.
     client_session_->OnConnectionClosed(client_session_->connection(),
                                         protocol::OK);
   }
 
   void QuitMainMessageLoop() {
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   void OnClientStopped() {
     client_session_ = NULL;
   }
 
   MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
   MockChromotingHostContext context_;
   SkISize screen_size_;
   std::string client_jid_;
   MockHostStub host_stub_;
   MockEventExecutor* event_executor_;
-  MockVideoFrameCapturer* capturer_;
   MockClientSessionEventHandler session_event_handler_;
   scoped_refptr<ClientSession> client_session_;
   SessionConfig session_config_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   protocol::ConnectionToClient* connection_;
+  scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
 MATCHER_P2(EqualsClipboardEvent, m, d, "") {
   return (strcmp(arg.mime_type().c_str(), m) == 0 &&
       memcmp(arg.data().data(), d, arg.data().size()) == 0);
 }
 
 TEST_F(ClientSessionTest, ClipboardStubFilter) {
   protocol::ClipboardEvent clipboard_event1;
   clipboard_event1.set_mime_type(kMimeTypeTextUtf8);
@@ skipping 202 matching lines @@
                                                         expected_y[j])))
               .After(connected);
       connection_->input_stub()->InjectMouseEvent(event);
     }
   }
 
   DisconnectClientSession();
 }
 
 }  // namespace remoting