debug on ios simulator

net/quic/core/quic_session.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // A QuicSession, which demuxes a single connection to individual streams.
 
 #ifndef NET_QUIC_CORE_QUIC_SESSION_H_
 #define NET_QUIC_CORE_QUIC_SESSION_H_
 
 #include <cstddef>
@@ skipping 38 matching lines @@
     // Called when the connection is closed after the streams have been closed.
     virtual void OnConnectionClosed(QuicConnectionId connection_id,
                                     QuicErrorCode error,
                                     const std::string& error_details) = 0;
 
     // Called when the session has become write blocked.
     virtual void OnWriteBlocked(QuicBlockedWriterInterface* blocked_writer) = 0;
 
     // Called when the session receives reset on a stream from the peer.
     virtual void OnRstStreamReceived(const QuicRstStreamFrame& frame) = 0;
+
+    virtual void OnPushPromiseSent() = 0;
   };
 
   // CryptoHandshakeEvent enumerates the events generated by a QuicCryptoStream.
   enum CryptoHandshakeEvent {
     // ENCRYPTION_FIRST_ESTABLISHED indicates that a full client hello has been
     // sent by a client and that subsequent packets will be encrypted. (Client
     // only.)
     ENCRYPTION_FIRST_ESTABLISHED,
     // ENCRYPTION_REESTABLISHED indicates that a client hello was rejected by
     // the server and thus the encryption key has been updated. Therefore the
@@ skipping 281 matching lines @@
   bool MaybeIncreaseLargestPeerStreamId(const QuicStreamId stream_id);
 
   void InsertLocallyClosedStreamsHighestOffset(const QuicStreamId id,
                                                QuicStreamOffset offset);
   // If stream is a locally closed stream, this RST will update FIN offset.
   // Otherwise stream is a preserved stream and the behavior of it depends on
   // derived class's own implementation.
   virtual void HandleRstOnValidNonexistentStream(
       const QuicRstStreamFrame& frame);
 
+  // May be null.
+  Visitor* visitor_;
+
  private:
   friend class test::QuicSessionPeer;
 
   // Called in OnConfigNegotiated when we receive a new stream level flow
   // control window in a negotiated config. Closes the connection if invalid.
   void OnNewStreamFlowControlWindow(QuicStreamOffset new_window);
 
   // Called in OnConfigNegotiated when we receive a new connection level flow
   // control window in a negotiated config. Closes the connection if invalid.
   void OnNewSessionFlowControlWindow(QuicStreamOffset new_window);
 
   // Debug helper for |OnCanWrite()|, check that OnStreamWrite() makes
   // forward progress.  Returns false if busy loop detected.
   bool CheckStreamNotBusyLooping(QuicStream* stream,
                                  uint64_t previous_bytes_written,
                                  bool previous_fin_sent);
 
   // Called in OnConfigNegotiated for Finch trials to measure performance of
   // starting with larger flow control receive windows.
   void AdjustInitialFlowControlWindows(size_t stream_window);
 
   // Keep track of highest received byte offset of locally closed streams, while
   // waiting for a definitive final highest offset from the peer.
   std::map<QuicStreamId, QuicStreamOffset>
       locally_closed_streams_highest_offset_;
 
   QuicConnection* connection_;
 
-  // May be null.
-  Visitor* visitor_;
-
   ClosedStreams closed_streams_;
 
   QuicConfig config_;
 
   // The maximum number of outgoing streams this connection can open.
   size_t max_open_outgoing_streams_;
 
   // The maximum number of incoming streams this connection will allow.
   size_t max_open_incoming_streams_;
 
@@ skipping 43 matching lines @@
 
   // Latched value of gfe2_reloadable_flag_quic_flow_control_invariant.
   const bool flow_control_invariant_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_SESSION_H_