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 36 matching lines @@
 }
 
 namespace cricket {
 
 class PortAllocator;
 class TransportChannel;
 class TransportChannelImpl;
 
 typedef std::vector<Candidate> Candidates;
 
-// 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 45 matching lines @@
   rtc::Thread* signaling_thread() const { return signaling_thread_; }
   // Returns the worker thread. The actual networking is done on this thread.
   rtc::Thread* worker_thread() const { return worker_thread_; }
 
   // Returns the content_name of this transport.
   const std::string& content_name() const { return content_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(); }
-  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);
   }
 
-  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 170 matching lines @@
 
   private:
     TransportChannelImpl *impl_;
     bool candidates_allocated_;
     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 requests signaling.
   void OnChannelRequestSignaling(TransportChannelImpl* channel);
 
   // Called when a candidate is ready from remote peer.
   void OnRemoteCandidate(const Candidate& candidate);
@@ skipping 13 matching lines @@
 
   // These are versions of the above methods that are called only on a
   // particular thread (s = signaling, w = worker).  The above methods post or
   // send a message to invoke this version.
   TransportChannelImpl* CreateChannel_w(int component);
   void DestroyChannel_w(int component);
   void ConnectChannels_w();
   void ResetChannels_w();
   void DestroyAllChannels_w();
   void OnRemoteCandidate_w(const Candidate& candidate);
-  void OnChannelReadableState_s();
   void OnChannelWritableState_s();
   void OnChannelReceivingState_s();
   void OnChannelRequestSignaling_s();
   void OnConnecting_s();
   void OnChannelRouteChange_s(const TransportChannel* channel,
                               const Candidate& remote_candidate);
   void OnChannelCandidatesAllocationDone_s();
 
   // Helper function that invokes the given function on every channel.
   typedef void (TransportChannelImpl::* TransportChannelFunc)();
@@ skipping 19 matching lines @@
   void SetChannelReceivingTimeout_w(int timeout_ms);
 
   // Sends SignalCompleted if we are now in that state.
   void MaybeCompleted_w();
 
   rtc::Thread* const signaling_thread_;
   rtc::Thread* const worker_thread_;
   const std::string content_name_;
   PortAllocator* const allocator_;
   bool destroyed_;
-  TransportState readable_;
   TransportState writable_;
   TransportState receiving_;
   bool was_writable_;
   bool connect_requested_;
   IceRole ice_role_;
   uint64 tiebreaker_;
   IceMode remote_ice_mode_;
   int channel_receiving_timeout_;
   rtc::scoped_ptr<TransportDescription> local_description_;
   rtc::scoped_ptr<TransportDescription> remote_description_;
 
   // TODO(tommi): Make sure we only use this on the worker thread.
   ChannelMap channels_;
   // Buffers the ready_candidates so that SignalCanidatesReady can
   // provide them in multiples.
   std::vector<Candidate> ready_candidates_;
   // Protects changes to channels and messages
   rtc::CriticalSection crit_;
 
   DISALLOW_COPY_AND_ASSIGN(Transport);
 };
 
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TRANSPORT_H_