Implement InputStub in the host side for chromoting

remoting/protocol/connection_to_client.h

 // Copyright (c) 2010 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_PROTOCOL_CONNECTION_TO_CLIENT_H_
 #define REMOTING_PROTOCOL_CONNECTION_TO_CLIENT_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
-#include "remoting/protocol/message_reader.h"
 #include "remoting/protocol/session.h"
 #include "remoting/protocol/stream_writer.h"
 #include "remoting/protocol/video_writer.h"
 
 namespace remoting {
 namespace protocol {
 
 class ClientStub;
+class HostStub;
+class InputStub;

[awong, 2010/11/10 19:36:54]

alphabetical order

+class HostMessageDispatcher;
 
 // This class represents a remote viewer connected to the chromoting host
 // through a libjingle connection. A viewer object is responsible for sending
 // screen updates and other messages to the remote viewer. It is also
 // responsible for receiving and parsing data from the remote viewer and
 // delegating events to the event handler.
 class ConnectionToClient :
-  public base::RefCountedThreadSafe<ConnectionToClient> {
+      public base::RefCountedThreadSafe<ConnectionToClient> {
  public:
   class EventHandler {
    public:
     virtual ~EventHandler() {}
 
-    // Handles an event received by the ConnectionToClient. Receiver will own
-    // the ClientMessages in ClientMessageList and needs to delete them.
-    // Note that the sender of messages will not reference messages
-    // again so it is okay to clear |messages| in this method.
-    virtual void HandleMessage(ConnectionToClient* connection,
-                               ChromotingClientMessage* message) = 0;
-
     // Called when the network connection is opened.
     virtual void OnConnectionOpened(ConnectionToClient* connection) = 0;
 
     // Called when the network connection is closed.
     virtual void OnConnectionClosed(ConnectionToClient* connection) = 0;
 
     // Called when the network connection has failed.
     virtual void OnConnectionFailed(ConnectionToClient* connection) = 0;
   };
 
   // Constructs a ConnectionToClient object. |message_loop| is the message loop
   // that this object runs on. A viewer object receives events and messages from
   // a libjingle channel, these events are delegated to |handler|.
   // It is guranteed that |handler| is called only on the |message_loop|.
   ConnectionToClient(MessageLoop* message_loop,
-                   EventHandler* handler);
+                     EventHandler* handler,
+                     HostStub* host_stub,
+                     InputStub* input_stub);
 
   virtual ~ConnectionToClient();
 
   virtual void Init(protocol::Session* session);
 
   // Returns the connection in use.
   virtual protocol::Session* session();
 
   // Send encoded update stream data to the viewer.
   virtual void SendVideoPacket(const VideoPacket& packet);
@@ skipping 14 matching lines @@
   virtual ClientStub* client_stub() { return client_stub_.get(); }
 
  protected:
   // Protected constructor used by unit test.
   ConnectionToClient();
 
  private:
   // Callback for protocol Session.
   void OnSessionStateChange(protocol::Session::State state);
 
-  // Callback for MessageReader.
-  void OnMessageReceived(ChromotingClientMessage* message);
-
   // Process a libjingle state change event on the |loop_|.
   void StateChangeTask(protocol::Session::State state);
 
-  // Process a data buffer received from libjingle.
-  void MessageReceivedTask(ChromotingClientMessage* message);
-
   void OnClosed();
 
   // The libjingle channel used to send and receive data from the remote client.
   scoped_refptr<protocol::Session> session_;
 
-  MessageReader event_reader_;
   scoped_ptr<VideoWriter> video_writer_;
 
   // ClientStub for sending messages to the client.
   scoped_ptr<ClientStub> client_stub_;
 
   // The message loop that this object runs on.
   MessageLoop* loop_;
 
   // Event handler for handling events sent from this object.
   EventHandler* handler_;
 
+  // HostStub for receiving control events from the client.
+  HostStub* host_stub_;
+
+  // InputStub for receiving input events from the client.
+  InputStub* input_stub_;
+
+  // Dispatcher for submitting messages to stubs.
+  scoped_ptr<HostMessageDispatcher> dispatcher_;

[Sergey Ulanov, 2010/11/10 20:14:21]

Does this need to be a pointer?

[Alpha Left Google, 2010/11/12 20:08:01]

Trying not to include a bunch of internal / protocol headers here.

+
   DISALLOW_COPY_AND_ASSIGN(ConnectionToClient);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_CONNECTION_TO_CLIENT_H_