RefCounted types should not have public destructors, delegate cleanup

remoting/protocol/session_manager.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.
 
 // The purpose of SessionManager is to facilitate creation of chromotocol
 // sessions. Both host and client use it to establish chromotocol
 // sessions. JingleChromotocolServer implements this inteface using
 // libjingle.
 //
 // OUTGOING SESSIONS
@@ skipping 58 matching lines @@
 
 class Authenticator;
 class AuthenticatorFactory;
 
 // Generic interface for Chromoting session manager.
 //
 // TODO(sergeyu): Split this into two separate interfaces: one for the
 // client side and one for the host side.
 class SessionManager : public base::NonThreadSafe {
  public:
-  SessionManager() { }
-  virtual ~SessionManager() { }
+  SessionManager() {}
+  virtual ~SessionManager() {}
 
   enum IncomingSessionResponse {
     // Accept the session.
     ACCEPT,
 
     // Reject the session due to incompatible session configuration.
     INCOMPATIBLE,
 
     // Reject the session because the host is currently disabled due
     // to previous login attempts.
     OVERLOAD,
 
     // Reject the session because the client is not allowed to connect
     // to the host.
     DECLINE,
   };
 
   class Listener {
    public:
-    Listener() { }
-    ~Listener() { }
+    Listener() {}
 
     // Called when the session manager is ready to create outgoing
     // sessions. May be called from Init() or after Init()
     // returns.
     virtual void OnSessionManagerReady() = 0;
 
     // Called when a new session is received. If the host decides to
     // accept the session it should set the |response| to
     // ACCEPT. Otherwise it should set it to DECLINE, or
     // INCOMPATIBLE. INCOMPATIBLE indicates that the session has
     // incompatible configuration, and cannot be accepted. If the
     // callback accepts the |session| then it must also set
     // configuration for the |session| using Session::set_config().
     // The callback must take ownership of the |session| if it ACCEPTs it.
     virtual void OnIncomingSession(Session* session,
                                    IncomingSessionResponse* response) = 0;
+
+   protected:
+    ~Listener() {}
   };
 
   // Initializes the session client. Caller retains ownership of the
   // |signal_strategy| and |listener|.
   virtual void Init(SignalStrategy* signal_strategy,
                     Listener* listener) = 0;
 
   // Tries to create a session to the host |jid|. Must be called only
   // after initialization has finished successfully, i.e. after
   // Listener::OnInitialized() has been called.
@@ skipping 22 matching lines @@
       scoped_ptr<AuthenticatorFactory> authenticator_factory) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SessionManager);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_SESSION_MANAGER_H_