Refactoring on QUIC

webrtc/api/quicdatachannel.h

 /*
  *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 70 matching lines @@
   // Message stores buffered data from the incoming QUIC stream. The QUIC stream
   // is provided so that remaining data can be received from the remote peer.
   struct Message {
     uint64_t id;
     rtc::CopyOnWriteBuffer buffer;
     cricket::ReliableQuicStream* stream;
   };
 
   QuicDataChannel(rtc::Thread* signaling_thread,
                   rtc::Thread* worker_thread,
+                  rtc::Thread* network_thread,
                   const std::string& label,
                   const DataChannelInit& config);
   ~QuicDataChannel() override;
 
   // DataChannelInterface overrides.
   std::string label() const override { return label_; }
   bool reliable() const override { return true; }
   bool ordered() const override { return false; }
   uint16_t maxRetransmitTime() const override { return -1; }
   uint16_t maxRetransmits() const override { return -1; }
@@ skipping 47 matching lines @@
   void OnIncomingQueuedStreamClosed(net::QuicStreamId stream_id, int error);
   // Called when a write blocked QUIC stream in |write_blocked_quic_streams_|
   // has written previously queued data.
   void OnQueuedBytesWritten(net::QuicStreamId stream_id,
                             uint64_t queued_bytes_written);
 
   // Callbacks from |quic_transport_channel_|.
   void OnReadyToSend(cricket::TransportChannel* channel);
   void OnConnectionClosed();
 
-  // Worker thread methods.
+  // Network thread methods.
   // Sends the data buffer to the remote peer using an outgoing QUIC stream.
   // Returns true if the data buffer can be successfully sent, or if it is
   // queued to be sent later.
-  bool Send_w(const DataBuffer& buffer);
+  bool Send_n(const DataBuffer& buffer);
+
+  // Worker thread methods.
   // Connects the |quic_transport_channel_| signals to this QuicDataChannel,
   // then returns the new QuicDataChannel state.
   DataState SetTransportChannel_w();
   // Closes the QUIC streams associated with this QuicDataChannel.
   void Close_w();
   // Sets |buffered_amount_|.
   void SetBufferedAmount_w(uint64_t buffered_amount);
 
   // Signaling thread methods.
   // Triggers QuicDataChannelObserver::OnMessage when a message from the remote
   // peer is ready to be read.
   void OnMessage_s(const DataBuffer& received_data);
   // Triggers QuicDataChannel::OnStateChange if the state change is valid.
   // Otherwise does nothing if |state| == |state_| or |state| != kClosed when
   // the data channel is closing.
   void SetState_s(DataState state);
   // Triggers QuicDataChannelObserver::OnBufferedAmountChange when the total
   // buffered data changes for a QUIC stream.
   void OnBufferedAmountChange_s(uint64_t buffered_amount);
 
   // QUIC transport channel which owns the QUIC session. It is used to create
   // a QUIC stream for sending outgoing messages.
   cricket::QuicTransportChannel* quic_transport_channel_ = nullptr;
   // Signaling thread for DataChannelInterface methods.
   rtc::Thread* const signaling_thread_;
-  // Worker thread for sending data and |quic_transport_channel_| callbacks.
+  // Worker thread for |quic_transport_channel_| callbacks.
   rtc::Thread* const worker_thread_;
+  // Network thread for sending data and |quic_transport_channel_| callbacks.
+  rtc::Thread* const network_thread_;
   rtc::AsyncInvoker invoker_;
   // Map of QUIC stream ID => ReliableQuicStream* for write blocked QUIC
   // streams.
   std::unordered_map<net::QuicStreamId, cricket::ReliableQuicStream*>
       write_blocked_quic_streams_;
   // Map of QUIC stream ID => Message for each incoming QUIC stream.
   std::unordered_map<net::QuicStreamId, Message> incoming_quic_messages_;
   // Handles received data from the remote peer and data channel state changes.
   DataChannelObserver* observer_ = nullptr;
   // QuicDataChannel ID.
   int id_;
   // Connectivity state of the QuicDataChannel.
   DataState state_;
   // Total bytes that are buffered among the QUIC streams.
   uint64_t buffered_amount_;
   // Counter for number of sent messages that is used for message IDs.
   uint64_t next_message_id_;
 
   // Variables for application use.
   const std::string& label_;
   const std::string& protocol_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_QUICDATACHANNEL_H_