Remove authenticated_ fields from stubs.

remoting/host/client_session.h

 // 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.
 
 #ifndef REMOTING_HOST_CLIENT_SESSION_H_
 #define REMOTING_HOST_CLIENT_SESSION_H_
 
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/host_stub.h"
+#include "remoting/protocol/input_stub.h"
 
 namespace remoting {
 
+class UserAuthenticator;
+
 // A ClientSession keeps a reference to a connection to a client, and maintains
 // per-client state.
 class ClientSession : public protocol::HostStub,
+                      public protocol::InputStub,
                       public base::RefCountedThreadSafe<ClientSession> {
  public:
   // Callback interface for passing events to the ChromotingHost.
   class EventHandler {
    public:
     virtual ~EventHandler() {}
 
     // Called to signal that local login has succeeded and ChromotingHost can
     // proceed with the next step.
     virtual void LocalLoginSucceeded(
         scoped_refptr<protocol::ConnectionToClient> client) = 0;
 
     // Called to signal that local login has failed.
     virtual void LocalLoginFailed(
         scoped_refptr<protocol::ConnectionToClient> client) = 0;
   };
 
+  typedef UserAuthenticator* UserAuthenticatorFactory();
+
   ClientSession(EventHandler* event_handler,
-                scoped_refptr<protocol::ConnectionToClient> connection);
+                const base::Callback<UserAuthenticatorFactory>& auth_factory,
+                scoped_refptr<protocol::ConnectionToClient> connection,
+                protocol::InputStub* input_stub);
 
   // protocol::HostStub interface.
   virtual void SuggestResolution(
       const protocol::SuggestResolutionRequest* msg, Task* done);
   virtual void BeginSessionRequest(
       const protocol::LocalLoginCredentials* credentials, Task* done);
 
+  // protocol::InputStub interface.
+  virtual void InjectKeyEvent(const protocol::KeyEvent* event, Task* done);
+  virtual void InjectMouseEvent(const protocol::MouseEvent* event, Task* done);
+
   // Disconnect this client session.
   void Disconnect();
 
-  protocol::ConnectionToClient* connection() const;
+  protocol::ConnectionToClient* connection() const {
+    return connection_.get();
+  }
 
- protected:
-  friend class base::RefCountedThreadSafe<ClientSession>;
-  ~ClientSession();
+  bool authenticated() const {
+    return authenticated_;
+  }
 
  private:
+  friend class base::RefCountedThreadSafe<ClientSession>;
+  virtual ~ClientSession();
+
   EventHandler* event_handler_;
+
+  // A factory for user authenticators.
+  base::Callback<UserAuthenticatorFactory> auth_factory_;
+
+  // The connection to the client.
   scoped_refptr<protocol::ConnectionToClient> connection_;
 
+  // The input stub to which this object delegates.
+  protocol::InputStub* input_stub_;
+
+  // Whether this client is authenticated.
+  bool authenticated_;
+
   DISALLOW_COPY_AND_ASSIGN(ClientSession);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CLIENT_SESSION_H_