The continue window is owned by the desktop environment now.

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/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "media/video/capture/screen/screen_capturer_fake.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_mock_objects.h"
-#include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::remoting::protocol::MockClientStub;
@@ skipping 28 matching lines @@
 }
 
 // Run the task and delete it afterwards. This action is used to deal with
 // done callbacks.
 ACTION(RunDoneTask) {
   arg1.Run();
 }
 
 }  // namespace
 
-class MockIt2MeHostUserInterface : public It2MeHostUserInterface {
- public:
-  MockIt2MeHostUserInterface(
-      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
-
-  void InitFrom(scoped_ptr<ContinueWindow> continue_window);
-
-  // A test-only version of Start that does not register a HostStatusObserver.
-  // TODO(rmsousa): Make the unit tests work with the regular Start().
-  virtual void Start(ChromotingHost* host,
-                     const base::Closure& disconnect_callback) OVERRIDE;
-};
-
-MockIt2MeHostUserInterface::MockIt2MeHostUserInterface(
-    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
-    : It2MeHostUserInterface(network_task_runner, ui_task_runner, UiStrings()) {
-}
-
-void MockIt2MeHostUserInterface::InitFrom(
-    scoped_ptr<ContinueWindow> continue_window) {
-  DCHECK(ui_task_runner()->BelongsToCurrentThread());
-
-  continue_window_ = continue_window.Pass();
-}
-
-void MockIt2MeHostUserInterface::Start(
-    ChromotingHost* host, const base::Closure& disconnect_callback) {
-  DCHECK(network_task_runner()->BelongsToCurrentThread());
-  DCHECK(host_ == NULL);
-
-  host_ = host;
-  disconnect_callback_ = disconnect_callback;
-}
-
 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)));
@@ skipping 14 matching lines @@
         desktop_environment_factory_.get(),
         scoped_ptr<protocol::SessionManager>(session_manager_),
         ui_task_runner_,  // Audio
         ui_task_runner_,  // Input
         ui_task_runner_,  // Video capture
         ui_task_runner_,  // Video encode
         ui_task_runner_,  // Network
         ui_task_runner_); // UI
     host_->AddStatusObserver(&host_status_observer_);
 
-    continue_window_ = new MockContinueWindow();
-    it2me_host_user_interface_.reset(
-        new MockIt2MeHostUserInterface(ui_task_runner_, ui_task_runner_));
-    it2me_host_user_interface_->InitFrom(
-        scoped_ptr<ContinueWindow>(continue_window_));
-
-    it2me_host_user_interface_->Start(
-        host_, base::Bind(&ChromotingHost::Shutdown, host_, base::Closure()));
-
     xmpp_login_ = "host@domain";
     session1_ = new MockSession();
     session2_ = new MockSession();
     session_unowned1_.reset(new MockSession());
     session_unowned2_.reset(new MockSession());
     session_config1_ = SessionConfig::ForTest();
     session_jid1_ = "user@domain/rest-of-jid";
     session_config2_ = SessionConfig::ForTest();
     session_jid2_ = "user2@domain/rest-of-jid";
     session_unowned_config1_ = SessionConfig::ForTest();
@@ skipping 192 matching lines @@
 
   void ShutdownHost() {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingHost::Shutdown, host_,
                    base::Bind(&ChromotingHostTest::ReleaseUiTaskRunner,
                               base::Unretained(this))));
   }
 
   void ReleaseUiTaskRunner() {
-    it2me_host_user_interface_.reset();
     ui_task_runner_ = NULL;
     host_ = NULL;
     desktop_environment_factory_.reset();
   }
 
   void QuitMainMessageLoop() {
     PostQuitTask(&message_loop_);
   }
 
-  // Expect the host to start.
-  void ExpectHostStart() {
-    EXPECT_CALL(*continue_window_, Hide());
-  }
-
   // Expect the host and session manager to start, and return the expectation
   // that the session manager has started.
   Expectation ExpectHostAndSessionManagerStart() {
-    ExpectHostStart();
     EXPECT_CALL(host_status_observer_, OnStart(xmpp_login_));
     return EXPECT_CALL(*session_manager_, Init(_, host_.get()));
   }
 
   // Expect a client to connect.
   // Return an expectation that a session has started, and that the first
   // video packet has been sent to the client.
   // Do |action| when that happens.
   template <class A>
   Expectation ExpectClientConnected(int connection_index, A action) {
@@ skipping 59 matching lines @@
           .RetiresOnSaturation();
     }
   }
 
  protected:
   MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
   MockConnectionToClientEventHandler handler_;
   MockSignalStrategy signal_strategy_;
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
-  scoped_ptr<MockIt2MeHostUserInterface> 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_|.
   SessionConfig session_config1_;
@@ skipping 12 matching lines @@
   scoped_ptr<MockSession> session_unowned1_;  // Not owned by a connection.
   SessionConfig session_unowned_config1_;
   std::string session_unowned_jid1_;
   scoped_ptr<MockSession> session_unowned2_;  // Not owned by a connection.
   SessionConfig session_unowned_config2_;
   std::string session_unowned_jid2_;
   protocol::Session::EventHandler* session_event_handler_;
   scoped_ptr<protocol::CandidateSessionConfig> empty_candidate_config_;
   scoped_ptr<protocol::CandidateSessionConfig> default_candidate_config_;
 
-  // Owned by |host_|.
-  MockContinueWindow* continue_window_;
-
   MockConnectionToClient*& get_connection(int connection_index) {
     return (connection_index == 0) ? connection1_ : connection2_;
   }
 
   ClientSession*& get_client(int connection_index) {
     return (connection_index == 0) ? client1_ : client2_;
   }
 
   const std::string& get_session_jid(int connection_index) {
     return (connection_index == 0) ? session_jid1_ : session_jid2_;
@@ skipping 98 matching lines @@
   Expectation client_disconnected2 = ExpectClientDisconnected(
       1, true, video_packet_sent2, InvokeWithoutArgs(base::DoNothing));
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(client_disconnected2);
 
   host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionDeclined) {
-  ExpectHostStart();
   protocol::SessionManager::IncomingSessionResponse response =
       protocol::SessionManager::ACCEPT;
   host_->OnIncomingSession(session1_, &response);
   EXPECT_EQ(protocol::SessionManager::DECLINE, response);
 
   ShutdownHost();
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, IncomingSessionIncompatible) {
@@ skipping 87 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