Inline two methods of QuicChromiumClientSession

net/quic/chromium/quic_chromium_client_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 client specific QuicSession subclass.  This class owns the underlying
 // QuicConnection and QuicConnectionHelper objects.  The connection stores
 // a non-owning pointer to the helper so this session needs to ensure that
 // the helper outlives the connection.
 
 #ifndef NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_SESSION_H_
@@ skipping 204 matching lines @@
                                  TokenBindingType tb_type,
                                  std::vector<uint8_t>* out) override;
 
   // Performs a crypto handshake with the server.
   int CryptoConnect(const CompletionCallback& callback);
 
   // Causes the QuicConnectionHelper to start reading from all sockets
   // and passing the data along to the QuicConnection.
   void StartReading();
 
   // Close the session because of |error| and notifies the factory

[Zhongyi Shi, 2017/04/29 21:05:19]

nit: |net_error|

[Ryan Hamilton, 2017/05/01 02:02:05]

Done.

   // that this session has been closed, which will delete the session.
-  void CloseSessionOnError(int error, QuicErrorCode quic_error);
+  void CloseSessionOnError(int net_error, QuicErrorCode quic_error);
 
   std::unique_ptr<base::Value> GetInfoAsValue(
       const std::set<HostPortPair>& aliases);
 
   const NetLogWithSource& net_log() const { return net_log_; }
 
   base::WeakPtr<QuicChromiumClientSession> GetWeakPtr();
 
   // Returns the number of client hello messages that have been sent on the
   // crypto stream. If the handshake has completed then this is one greater
@@ skipping 92 matching lines @@
   typedef std::set<Observer*> ObserverSet;
   typedef std::list<StreamRequest*> StreamRequestQueue;
 
   QuicChromiumClientStream* CreateOutgoingReliableStreamImpl();
   QuicChromiumClientStream* CreateIncomingReliableStreamImpl(QuicStreamId id);
   // A completion callback invoked when a read completes.
   void OnReadComplete(int result);
 
   void OnClosedStream();
 
-  // Close the session because of |error| and records it in UMA histogram.
-  void RecordAndCloseSessionOnError(int error, QuicErrorCode quic_error);
-
-  // A Session may be closed via any of three methods:
-  // OnConnectionClosed - called by the connection when the connection has been
-  //     closed, perhaps due to a timeout or a protocol error.
-  // CloseSessionOnError - called from the owner of the session,
-  //     the QuicStreamFactory, when there is an error.
-  // OnReadComplete - when there is a read error.
-  // This method closes all stream and performs any necessary cleanup.
-  void CloseSessionOnErrorInner(int net_error, QuicErrorCode quic_error);
-
   void CloseAllStreams(int net_error);
   void CloseAllObservers(int net_error);
   void CancelAllRequests(int net_error);
 
   // Notifies the factory that this session is going away and no more streams
   // should be created from it.  This needs to be called before closing any
   // streams, because closing a stream may cause a new stream to be created.
   void NotifyFactoryOfSessionGoingAway();
 
   // Posts a task to notify the factory that this session has been closed.
@@ skipping 46 matching lines @@
   // the current sockets_.size() == the passed in value.
   bool migration_pending_;  // True while migration is underway.
   base::WeakPtrFactory<QuicChromiumClientSession> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicChromiumClientSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_SESSION_H_