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.
   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.
   //
   // 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);
+  // Shuts down the host process.
+  void Shutdown();

[Wez, 2013/04/02 19:58:33]

Rename this Stop() to match Start().

[alexeypa (please no reviews), 2013/04/08 23:28:17]

I moved the logic to the destructor.

 
   // 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();
 
@@ skipping 25 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.

[Wez, 2013/04/02 19:58:33]

Clarify the semantics, e.g. might sub-components asynchronously shutdown in the
background?

[alexeypa (please no reviews), 2013/04/08 23:28:17]

Done.

   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_;
@@ skipping 18 matching lines @@
   // 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_