Replace readable with receiving where receiving means receiving anything (stun ping, response or da…

webrtc/p2p/base/transport.h

 /*
  *  Copyright 2004 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 47 matching lines @@
 
 // TODO(deadbeef): Unify with PeerConnectionInterface::IceConnectionState
 // once /talk/ and /webrtc/ are combined, and also switch to ENUM_NAME naming
 // style.
 enum IceGatheringState {
   kIceGatheringNew = 0,
   kIceGatheringGathering,
   kIceGatheringComplete,
 };
 
-// For "writable", "readable", and "receiving", we need to differentiate between
+// For "writable" and "receiving", we need to differentiate between
 // none, all, and some.
 enum TransportState {
   TRANSPORT_STATE_NONE = 0,
   TRANSPORT_STATE_SOME,
   TRANSPORT_STATE_ALL
 };
 
 // When checking transport state, we need to differentiate between
-// "readable", "writable", or "receiving" check.
+// "writable" or "receiving" check.
 enum TransportStateType {
-  TRANSPORT_READABLE_STATE = 0,
-  TRANSPORT_WRITABLE_STATE,
+  TRANSPORT_WRITABLE_STATE = 0,
   TRANSPORT_RECEIVING_STATE
 };
 
 // Stats that we can return about the connections for a transport channel.
 // TODO(hta): Rename to ConnectionStats
 struct ConnectionInfo {
   ConnectionInfo()
       : best_connection(false),
         writable(false),
-        readable(false),
         timeout(false),
         new_connection(false),
         rtt(0),
         sent_total_bytes(0),
         sent_bytes_second(0),
         sent_discarded_packets(0),
         sent_total_packets(0),
         recv_total_bytes(0),
         recv_bytes_second(0),
         key(NULL) {}
 
   bool best_connection;        // Is this the best connection we have?
   bool writable;               // Has this connection received a STUN response?
-  bool readable;               // Has this connection received a STUN request?
+  bool receiving;              // Has this connection received anything?
   bool timeout;                // Has this connection timed out?
   bool new_connection;         // Is this a newly created connection?
   size_t rtt;                  // The STUN RTT for this connection.
   size_t sent_total_bytes;     // Total bytes sent on this connection.
   size_t sent_bytes_second;    // Bps over the last measurement interval.
   size_t sent_discarded_packets;  // Number of outgoing packets discarded due to
                                   // socket errors.
   size_t sent_total_packets;  // Number of total outgoing packets attempted for
                               // sending.
 
@@ skipping 36 matching lines @@
  public:
   Transport(const std::string& name, PortAllocator* allocator);
   virtual ~Transport();
 
   // Returns the name of this transport.
   const std::string& name() const { return name_; }
 
   // Returns the port allocator object for this transport.
   PortAllocator* port_allocator() { return allocator_; }
 
-  // Returns the readable and states of this manager.  These bits are the ORs
+  // Returns the states of this manager.  These bits are the ORs
   // of the corresponding bits on the managed channels.  Each time one of these
   // states changes, a signal is raised.
-  // TODO: Replace uses of readable() and writable() with
-  // any_channels_readable() and any_channels_writable().
-  bool readable() const { return any_channels_readable(); }
+  // TODO(honghaiz): Replace uses of writable() with any_channels_writable().
   bool writable() const { return any_channels_writable(); }
   bool was_writable() const { return was_writable_; }
-  bool any_channels_readable() const {
-    return (readable_ == TRANSPORT_STATE_SOME ||
-            readable_ == TRANSPORT_STATE_ALL);
-  }
   bool any_channels_writable() const {
     return (writable_ == TRANSPORT_STATE_SOME ||
             writable_ == TRANSPORT_STATE_ALL);
   }
-  bool all_channels_readable() const {
-    return (readable_ == TRANSPORT_STATE_ALL);
-  }
   bool all_channels_writable() const {
     return (writable_ == TRANSPORT_STATE_ALL);
   }
   bool any_channel_receiving() const {
     return (receiving_ == TRANSPORT_STATE_SOME ||
             receiving_ == TRANSPORT_STATE_ALL);
   }
   bool ready_for_remote_candidates() const {
     return local_description_set_ && remote_description_set_;
   }
 
   bool AllChannelsCompleted() const;
   bool AnyChannelFailed() const;
 
   IceGatheringState gathering_state() const { return gathering_state_; }
 
-  sigslot::signal1<Transport*> SignalReadableState;
   sigslot::signal1<Transport*> SignalWritableState;
   sigslot::signal1<Transport*> SignalReceivingState;
   sigslot::signal1<Transport*> SignalCompleted;
   sigslot::signal1<Transport*> SignalFailed;
 
   // Returns whether the client has requested the channels to connect.
   bool connect_requested() const { return connect_requested_; }
 
   void SetIceRole(IceRole role);
   IceRole ice_role() const { return ice_role_; }
@@ skipping 145 matching lines @@
     TransportChannelImpl* operator->() const  { return impl_; }
 
    private:
     TransportChannelImpl* impl_;
     int ref_;
   };
 
   // Candidate component => ChannelMapEntry
   typedef std::map<int, ChannelMapEntry> ChannelMap;
 
-  // Called when the state of a channel changes.
-  void OnChannelReadableState(TransportChannel* channel);
+  // Called when the write state of a channel changes.
   void OnChannelWritableState(TransportChannel* channel);
 
   // Called when the receiving state of a channel changes.
   void OnChannelReceivingState(TransportChannel* channel);
 
   // Called when a channel starts finishes gathering candidates
   void OnChannelGatheringState(TransportChannelImpl* channel);
 
   // Called when a candidate is ready from channel.
   void OnChannelCandidateGathered(TransportChannelImpl* channel,
@@ skipping 46 matching lines @@
   // provide them in multiples.
   std::vector<Candidate> ready_candidates_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Transport);
 };
 
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TRANSPORT_H_