Made the ChromotingHost class not ref-counted.

remoting/host/chromoting_host.h

 // 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.
 
 #ifndef REMOTING_HOST_CHROMOTING_HOST_H_
 #define REMOTING_HOST_CHROMOTING_HOST_H_
 
 #include <list>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "net/base/backoff_entry.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/host_status_monitor.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/session_manager.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "third_party/skia/include/core/SkSize.h"
 
@@ skipping 27 matching lines @@
 //    ConnectionToClient to receive mouse / keyboard events from the remote
 //    client.
 //    After we have done all the initialization we'll start the ScreenRecorder.
 //    We'll then enter the running state of the host process.
 //
 // 3. When the user is disconnected, we will pause the ScreenRecorder
 //    and try to terminate the threads we have created. This will allow
 //    all pending tasks to complete. After all of that completed we
 //    return to the idle state. We then go to step (2) if there a new
 //    incoming connection.
-class ChromotingHost : public base::RefCountedThreadSafe<ChromotingHost>,
+class ChromotingHost : public base::NonThreadSafe,
                        public ClientSession::EventHandler,
                        public protocol::SessionManager::Listener,
                        public HostStatusMonitor {
  public:
-  // The caller must ensure that |signal_strategy| and
-  // |desktop_environment_factory| remain valid at least until the
-  // |shutdown_task| supplied to Shutdown() has been notified.
+  // Both |signal_strategy| and |desktop_environment_factory| should outlive
+  // this object.
   ChromotingHost(
       SignalStrategy* signal_strategy,
       DesktopEnvironmentFactory* desktop_environment_factory,
       scoped_ptr<protocol::SessionManager> session_manager,
       scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
+  virtual ~ChromotingHost();
 
-  // Asynchronously start the host process.
+  // Asynchronously starts the host.
   //
   // After this is invoked, the host process will connect to the talk
   // network and start listening for incoming connections.
   //
   // This method can only be called once during the lifetime of this object.
   void Start(const std::string& xmpp_login);
 
-  // Asynchronously shutdown the host process. |shutdown_task| is
-  // called after shutdown is completed.
-  void Shutdown(const base::Closure& shutdown_task);
-
   // HostStatusMonitor interface.
   virtual void AddStatusObserver(HostStatusObserver* observer) OVERRIDE;
   virtual void RemoveStatusObserver(HostStatusObserver* observer) OVERRIDE;
 
   // This method may be called only from
   // HostStatusObserver::OnClientAuthenticated() to reject the new
   // client.
   void RejectAuthenticatingClient();
 
   // Sets the authenticator factory to use for incoming
@@ skipping 24 matching lines @@
 
   // SessionManager::Listener implementation.
   virtual void OnSessionManagerReady() OVERRIDE;
   virtual void OnIncomingSession(
       protocol::Session* session,
       protocol::SessionManager::IncomingSessionResponse* response) OVERRIDE;
 
   // Sets desired configuration for the protocol. Must be called before Start().
   void set_protocol_config(scoped_ptr<protocol::CandidateSessionConfig> config);
 
-  // Disconnects all active clients. Clients are disconnected
-  // asynchronously when this method is called on a thread other than
-  // the network thread. Potentically this may cause disconnection of
-  // clients that were not connected when this method is called.
+  // Disconnects all active clients synchronously. Sub-components might shutdown

[Wez, 2013/04/15 19:50:04]

nit: synchronously implies blocking.  Suggest:

"Immediately disconnects all active clients.  Host-internal components may
shutdown asynchronously, but the caller is guaranteed not to receive callbacks
for disconnected clients after this call returns."

[alexeypa (please no reviews), 2013/04/15 20:04:42]

Done.

+  // asynchronously (when they are running on different threads). No callbacks
+  // will be posted to the host in any case.
   void DisconnectAllClients();
 
   base::WeakPtr<ChromotingHost> AsWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
  private:
-  friend class base::RefCountedThreadSafe<ChromotingHost>;
   friend class ChromotingHostTest;
 
   typedef std::list<ClientSession*> ClientList;
 
-  enum State {
-    kInitial,
-    kStarted,
-    kStopping,
-    kStopped,
-  };
-
-  virtual ~ChromotingHost();
-
-  // Called from Shutdown() to finish shutdown.
-  void ShutdownFinish();
-
   // Unless specified otherwise all members of this class must be
   // used on the network thread only.
 
   // Parameters specified when the host was created.
   DesktopEnvironmentFactory* desktop_environment_factory_;
   scoped_ptr<protocol::SessionManager> session_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
   // Connection objects.
   SignalStrategy* signal_strategy_;
 
   // Must be used on the network thread only.
   ObserverList<HostStatusObserver> status_observers_;
 
   // The connections to remote clients.
   ClientList clients_;
 
-  // Tracks the internal state of the host.
-  State state_;
+  // True if the host has been started.
+  bool started_;
 
   // Configuration of the protocol.
   scoped_ptr<protocol::CandidateSessionConfig> protocol_config_;
 
   // Login backoff state.
   net::BackoffEntry login_backoff_;
 
   // Flags used for RejectAuthenticatingClient().
   bool authenticating_client_;
   bool reject_authenticating_client_;
 
-  // Stores list of tasks that should be executed when we finish
-  // shutdown. Used only while |state_| is set to kStopping.
-  std::vector<base::Closure> shutdown_tasks_;
-
   // The maximum duration of any session.
   base::TimeDelta max_session_duration_;
 
   base::WeakPtrFactory<ChromotingHost> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromotingHost);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CHROMOTING_HOST_H_