Refactor IT2Me-specific functions into a HostObserver subclass.

remoting/host/chromoting_host.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 "remoting/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
 #include "remoting/host/chromoting_host_context.h"
-#include "remoting/host/curtain.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/screen_recorder.h"
 #include "remoting/host/user_authenticator.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
@@ skipping 22 matching lines @@
                                AccessVerifier* access_verifier,
                                bool allow_nat_traversal)
     : context_(context),
       desktop_environment_(environment),
       config_(config),
       access_verifier_(access_verifier),
       allow_nat_traversal_(allow_nat_traversal),
       stopping_recorders_(0),
       state_(kInitial),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
-      is_curtained_(false),
       is_it2me_(false) {
   DCHECK(desktop_environment_);
   desktop_environment_->set_host(this);
 }
 
 ChromotingHost::~ChromotingHost() {
   DCHECK(clients_.empty());
 }
 
 void ChromotingHost::Start() {
@@ skipping 122 matching lines @@
   // Immediately add the connection and start the session.
   recorder_->AddConnection(client->connection());
   recorder_->Start();
 
   // Notify observers that there is at least one authenticated client.
   const std::string& jid = client->connection()->session()->jid();
   for (StatusObserverList::iterator it = status_observers_.begin();
        it != status_observers_.end(); ++it) {
     (*it)->OnClientAuthenticated(jid);
   }
-  // TODO(jamiewalch): Tidy up actions to be taken on connect/disconnect,
-  // including closing the connection on failure of a critical operation.
-  EnableCurtainMode(true);
-
-  std::string username = jid.substr(0, jid.find('/'));
-  desktop_environment_->OnConnect(username);
 }
 
 void ChromotingHost::OnSessionClosed(ClientSession* client) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   scoped_ptr<ClientSession> client_destroyer(client);
 
   ClientList::iterator it = std::find(clients_.begin(), clients_.end(), client);
   CHECK(it != clients_.end());
   clients_.erase(it);
 
   if (recorder_.get()) {
     recorder_->RemoveConnection(client->connection());
   }
 
   for (StatusObserverList::iterator it = status_observers_.begin();
        it != status_observers_.end(); ++it) {
     (*it)->OnClientDisconnected(client->client_jid());
   }
 
   if (AuthenticatedClientsCount() == 0) {
     if (recorder_.get()) {
       // Stop the recorder if there are no more clients.
       StopScreenRecorder();
     }
-
-    // Disable the "curtain" if there are no more active clients.
-    EnableCurtainMode(false);
-    desktop_environment_->OnLastDisconnect();
   }
 }
 
 void ChromotingHost::OnSessionSequenceNumber(ClientSession* session,
                                              int64 sequence_number) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   if (recorder_.get())
     recorder_->UpdateSequenceNumber(sequence_number);
 }
 
@@ skipping 65 matching lines @@
     // Notify observers.
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnAccessDenied();
     }
     return;
   }
 
   // If we are running Me2Mom and already have an authenticated client then
   // one of the connections may be an attacker, so both are suspect.
   if (is_it2me_ && AuthenticatedClientsCount() > 0) {

[Sergey Ulanov, 2011/11/30 21:24:37]

I think we can remove is_it2me_ flag now. Here we should always reject second
connection, for Me2Me too - it will not work properly anyway.

[Lambros, 2011/11/30 22:09:41]

I will address this in a followup CL.  Dealing with a second connection should
be different between IT2Me (shutdown the Host), and Me2Me (disconnect the first
connection and allow the new connection to proceed).  So the logic needs to be
moved to It2Me- and Me2Me-specific classes.

     *response = protocol::SessionManager::DECLINE;
 
     // Close existing sessions and shutdown the host.
     Shutdown(base::Closure());
     return;
   }
 
   // TODO(simonmorris): The resolution is set in the video stream now,
   // so it doesn't need to be set here.
   *protocol_config_->mutable_initial_resolution() =
@@ skipping 52 matching lines @@
   if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::PauseSession, this, pause));
     return;
   }
 
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     (*client)->set_awaiting_continue_approval(pause);
   }
-  desktop_environment_->OnPause(pause);
 }
 
 void ChromotingHost::SetUiStrings(const UiStrings& ui_strings) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
   DCHECK_EQ(state_, kInitial);
 
   ui_strings_ = ui_strings;
 }
 
 // TODO(sergeyu): Move this to SessionManager?
@@ skipping 22 matching lines @@
 
   int authenticated_clients = 0;
   for (ClientList::const_iterator it = clients_.begin(); it != clients_.end();
        ++it) {
     if ((*it)->authenticated())
       ++authenticated_clients;
   }
   return authenticated_clients;
 }
 
-void ChromotingHost::EnableCurtainMode(bool enable) {
-  // TODO(jamiewalch): This will need to be more sophisticated when we think
-  // about proper crash recovery and daemon mode.
-  // TODO(wez): CurtainMode shouldn't be driven directly by ChromotingHost.
-  if (is_it2me_ || enable == is_curtained_)
-    return;
-  desktop_environment_->curtain()->EnableCurtainMode(enable);
-  is_curtained_ = enable;
-}
-
 void ChromotingHost::StopScreenRecorder() {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   DCHECK(recorder_.get());
 
   ++stopping_recorders_;
   scoped_refptr<ScreenRecorder> recorder = recorder_;
   recorder_ = NULL;
   recorder->Stop(base::Bind(&ChromotingHost::OnScreenRecorderStopped, this));
 }
 
@@ skipping 27 matching lines @@
   }
 
   for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting