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

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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 48 matching lines @@
 // done callbacks.
 ACTION(RunDoneTask) {
   arg1.Run();
 }
 
 void DoNothing() {
 }
 
 }  // namespace
 
-class MockDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
- public:
-  MockDesktopEnvironmentFactory();
-  virtual ~MockDesktopEnvironmentFactory();
-
-  virtual scoped_ptr<DesktopEnvironment> Create() OVERRIDE;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockDesktopEnvironmentFactory);
-};
-
-MockDesktopEnvironmentFactory::MockDesktopEnvironmentFactory()
-    : DesktopEnvironmentFactory(NULL, NULL) {
-}
-
-MockDesktopEnvironmentFactory::~MockDesktopEnvironmentFactory() {
-}
-
-scoped_ptr<DesktopEnvironment> MockDesktopEnvironmentFactory::Create() {
-  scoped_ptr<EventExecutor> event_executor(new EventExecutorFake());
-  scoped_ptr<VideoFrameCapturer> video_capturer(new VideoFrameCapturerFake());
-  return scoped_ptr<DesktopEnvironment>(new DesktopEnvironment(
-      scoped_ptr<AudioCapturer>(NULL),
-      event_executor.Pass(),
-      video_capturer.Pass()));
-}
-
 class ChromotingHostTest : public testing::Test {
  public:
   ChromotingHostTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     ui_task_runner_ = new AutoThreadTaskRunner(
         message_loop_.message_loop_proxy(),
         base::Bind(&ChromotingHostTest::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()));
 
     desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
+    EXPECT_CALL(*desktop_environment_factory_, CreatePtr(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(Invoke(this,
+                               &ChromotingHostTest::CreateDesktopEnvironment));
+
     session_manager_ = new protocol::MockSessionManager();
 
     host_ = new ChromotingHost(
         &signal_strategy_,
         desktop_environment_factory_.get(),
         scoped_ptr<protocol::SessionManager>(session_manager_),
         context_.capture_task_runner(),
         context_.encode_task_runner(),
         context_.network_task_runner());
     host_->AddStatusObserver(&host_status_observer_);
@@ skipping 89 matching lines @@
         protocol::CandidateSessionConfig::CreateDefault();
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate,
                                 bool reject) {
     scoped_ptr<protocol::ConnectionToClient> connection =
         ((connection_index == 0) ? owned_connection1_ : owned_connection2_).
         PassAs<protocol::ConnectionToClient>();
     protocol::ConnectionToClient* connection_ptr = connection.get();
-    scoped_ptr<DesktopEnvironment> desktop_environment =
-        host_->desktop_environment_factory_->Create();
-    connection_ptr->set_input_stub(desktop_environment->event_executor());
-
     scoped_refptr<ClientSession> client = new ClientSession(
         host_.get(),
         context_.capture_task_runner(),
         context_.encode_task_runner(),
         context_.network_task_runner(),
         connection.Pass(),
-        desktop_environment.Pass(),
+        desktop_environment_factory_.get(),
         base::TimeDelta());
     connection_ptr->set_host_stub(client);
+    connection_ptr->set_input_stub(
+        client->desktop_environment()->event_executor());
 
     context_.network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHostTest::AddClientToHost,
                               host_, client));
 
     if (authenticate) {
       context_.network_task_runner()->PostTask(
           FROM_HERE, base::Bind(&ClientSession::OnConnectionAuthenticated,
                                 client, connection_ptr));
       if (!reject) {
@@ skipping 16 matching lines @@
     // Make sure that the host has been properly deleted.
     DCHECK(host_.get() == NULL);
   }
 
   // Change the session route for |client1_|.
   void ChangeSessionRoute(const std::string& channel_name,
                           const protocol::TransportRoute& route) {
     host_->OnSessionRouteChange(get_client(0), channel_name, route);
   }
 
+  DesktopEnvironment* CreateDesktopEnvironment(ClientSession* client) {
+    scoped_ptr<EventExecutor> event_executor(new EventExecutorFake());
+    scoped_ptr<VideoFrameCapturer> video_capturer(new VideoFrameCapturerFake());
+    return new DesktopEnvironment(scoped_ptr<AudioCapturer>(NULL),
+                                  event_executor.Pass(),
+                                  video_capturer.Pass());
+  }
+
   void DisconnectAllClients() {
     host_->DisconnectAllClients();
   }
 
   // Helper method to disconnect client 1 from the host.
   void DisconnectClient1() {
     client1_->OnConnectionClosed(connection1_, protocol::OK);
   }
 
   // Notify |host_| that the authenticating client has been rejected.
@@ skipping 122 matching lines @@
           .RetiresOnSaturation();
     }
   }
 
  protected:
   MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
   MockChromotingHostContext context_;
   MockConnectionToClientEventHandler handler_;
   MockSignalStrategy signal_strategy_;
-  scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
+  scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_refptr<ChromotingHost> host_;
   MockHostStatusObserver host_status_observer_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   MockConnectionToClient* connection1_;
   scoped_ptr<MockConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
@@ skipping 243 matching lines @@
   ExpectClientDisconnected(0, true, video_packet_sent,
       InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 }  // namespace remoting