remoting/protocol/channel_multiplexer.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_MULTIPLEXER_H_
   6 #define REMOTING_PROTOCOL_CHANNEL_MULTIPLEXER_H_
   7
   8 #include "base/memory/weak_ptr.h"
   9 #include "remoting/proto/mux.pb.h"
  10 #include "remoting/protocol/buffered_socket_writer.h"
  11 #include "remoting/protocol/message_reader.h"
  12 #include "remoting/protocol/protobuf_message_parser.h"
  13 #include "remoting/protocol/stream_channel_factory.h"
  14
  15 namespace remoting {
  16 namespace protocol {
  17
  18 class ChannelMultiplexer : public StreamChannelFactory {
  19  public:
  20   static const char kMuxChannelName[];
  21
  22   // |factory| is used to create the channel upon which to multiplex.
  23   ChannelMultiplexer(StreamChannelFactory* factory,
  24                      const std::string& base_channel_name);
  25   ~ChannelMultiplexer() override;
  26
  27   // StreamChannelFactory interface.
  28   void CreateChannel(const std::string& name,
  29                      const ChannelCreatedCallback& callback) override;
  30   void CancelChannelCreation(const std::string& name) override;
  31
  32  private:
  33   struct PendingChannel;
  34   class MuxChannel;
  35   class MuxSocket;
  36   friend class MuxChannel;
  37
  38   // Callback for |base_channel_| creation.
  39   void OnBaseChannelReady(scoped_ptr<net::StreamSocket> socket);
  40
  41   // Helper to create channels asynchronously.
  42   void DoCreatePendingChannels();
  43
  44   // Helper method used to create channels.
  45   MuxChannel* GetOrCreateChannel(const std::string& name);
  46
  47   // Error handling callback for |writer_|.
  48   void OnWriteFailed(int error);
  49
  50   // Failed write notifier, queued asynchronously by OnWriteFailed().
  51   void NotifyWriteFailed(const std::string& name);
  52
  53   // Callback for |reader_;
  54   void OnIncomingPacket(scoped_ptr<MultiplexPacket> packet,
  55                         const base::Closure& done_task);
  56
  57   // Called by MuxChannel.
  58   bool DoWrite(scoped_ptr<MultiplexPacket> packet,
  59                const base::Closure& done_task);
  60
  61   // Factory used to create |base_channel_|. Set to nullptr once creation is
  62   // finished or failed.
  63   StreamChannelFactory* base_channel_factory_;
  64
  65   // Name of the underlying channel.
  66   std::string base_channel_name_;
  67
  68   // The channel over which to multiplex.
  69   scoped_ptr<net::StreamSocket> base_channel_;
  70
  71   // List of requested channels while we are waiting for |base_channel_|.
  72   std::list<PendingChannel> pending_channels_;
  73
  74   int next_channel_id_;
  75   std::map<std::string, MuxChannel*> channels_;
  76
  77   // Channels are added to |channels_by_receive_id_| only after we receive
  78   // receive_id from the remote peer.
  79   std::map<int, MuxChannel*> channels_by_receive_id_;
  80
  81   BufferedSocketWriter writer_;
  82   MessageReader reader_;
  83   ProtobufMessageParser<MultiplexPacket> parser_;
  84
  85   base::WeakPtrFactory<ChannelMultiplexer> weak_factory_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(ChannelMultiplexer);
  88 };
  89
  90 }  // namespace protocol
  91 }  // namespace remoting
  92
  93
  94 #endif  // REMOTING_PROTOCOL_CHANNEL_MULTIPLEXER_H_