Made DesktopEnvironment responsible for creation of the disconnect window.

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"
@@ skipping 50 matching lines @@
 }
 
 }  // 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<DisconnectWindow> disconnect_window,
-      scoped_ptr<ContinueWindow> continue_window);
+  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<DisconnectWindow> disconnect_window,
     scoped_ptr<ContinueWindow> continue_window) {
   DCHECK(ui_task_runner()->BelongsToCurrentThread());
 
-  disconnect_window_ = disconnect_window.Pass();
   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;
@@ skipping 26 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_);
 
-    disconnect_window_ = new MockDisconnectWindow();
     continue_window_ = new MockContinueWindow();
     it2me_host_user_interface_.reset(
         new MockIt2MeHostUserInterface(ui_task_runner_, ui_task_runner_));
     it2me_host_user_interface_->InitFrom(
-        scoped_ptr<DisconnectWindow>(disconnect_window_),
         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());
@@ skipping 209 matching lines @@
     host_ = NULL;
     desktop_environment_factory_.reset();
   }
 
   void QuitMainMessageLoop() {
     PostQuitTask(&message_loop_);
   }
 
   // Expect the host to start.
   void ExpectHostStart() {
-    EXPECT_CALL(*disconnect_window_, Hide());
     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()));
   }
@@ skipping 100 matching lines @@
   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_|.
-  MockDisconnectWindow* disconnect_window_;
   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_;
   }
 
@@ skipping 208 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