remoting/protocol/channel_dispatcher_base.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef REMOTING_PROTOCOL_CHANNEL_DISPATCHER_BASE_H_
   6 #define REMOTING_PROTOCOL_CHANNEL_DISPATCHER_BASE_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "remoting/base/buffered_socket_writer.h"
  14 #include "remoting/protocol/errors.h"
  15 #include "remoting/protocol/message_reader.h"
  16
  17 namespace net {
  18 class StreamSocket;
  19 }  // namespace net
  20
  21 namespace remoting {
  22 namespace protocol {
  23
  24 struct ChannelConfig;
  25 class StreamChannelFactory;
  26 class Session;
  27
  28 // Base class for channel message dispatchers. It's responsible for
  29 // creating the named channel. Derived dispatchers then dispatch
  30 // incoming messages on this channel as well as send outgoing
  31 // messages.
  32 class ChannelDispatcherBase {
  33  public:
  34   class EventHandler {
  35    public:
  36     EventHandler() {}
  37     virtual ~EventHandler() {}
  38
  39     virtual void OnChannelInitialized(
  40         ChannelDispatcherBase* channel_dispatcher) = 0;
  41     virtual void OnChannelError(ChannelDispatcherBase* channel_dispatcher,
  42                                 ErrorCode error) = 0;
  43   };
  44
  45   // The callback is called when initialization is finished. The
  46   // parameter is set to true on success.
  47   typedef base::Callback<void(bool)> InitializedCallback;
  48
  49   virtual ~ChannelDispatcherBase();
  50
  51   // Creates and connects the channel in the specified
  52   // |session|. Caller retains ownership of the Session.
  53   void Init(Session* session,
  54             const ChannelConfig& config,
  55             EventHandler* event_handler);
  56
  57   const std::string& channel_name() { return channel_name_; }
  58
  59   // Returns true if the channel is currently connected.
  60   bool is_connected() { return channel_ != nullptr; }
  61
  62  protected:
  63   explicit ChannelDispatcherBase(const char* channel_name);
  64
  65   BufferedSocketWriter* writer() { return &writer_; }
  66   MessageReader* reader() { return &reader_; }
  67
  68  private:
  69   void OnChannelReady(scoped_ptr<net::StreamSocket> socket);
  70   void OnWriteFailed(int error);
  71
  72   std::string channel_name_;
  73   StreamChannelFactory* channel_factory_;
  74   EventHandler* event_handler_;
  75   scoped_ptr<net::StreamSocket> channel_;
  76
  77   BufferedSocketWriter writer_;
  78   MessageReader reader_;
  79
  80   DISALLOW_COPY_AND_ASSIGN(ChannelDispatcherBase);
  81 };
  82
  83 }  // namespace protocol
  84 }  // namespace remoting
  85
  86 #endif  // REMOTING_PROTOCOL_CHANNEL_DISPATCHER_BASE_H_