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/screen_recorder.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"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
@@ skipping 17 matching lines @@
                                MutableHostConfig* config,
                                DesktopEnvironment* environment,
                                bool allow_nat_traversal)
     : context_(context),
       desktop_environment_(environment),
       config_(config),
       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 135 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::OnSessionAuthenticationFailed(ClientSession* client) {
   // Notify observers.
   for (StatusObserverList::iterator it = status_observers_.begin();
        it != status_observers_.end(); ++it) {
     (*it)->OnAccessDenied();
   }
 }
 
@@ skipping 13 matching lines @@
   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 112 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 16 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