Make QuicFramer unaware of path. Also, send/receive PathClose has no effect.

net/quic/core/quic_framer.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.
 
 #ifndef NET_QUIC_CORE_QUIC_FRAMER_H_
 #define NET_QUIC_CORE_QUIC_FRAMER_H_
 
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
 
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/platform/api/quic_export.h"
 
 namespace net {
 
 namespace test {
 class QuicFramerPeer;
@@ skipping 301 matching lines @@
 
   void SetSupportedVersions(const QuicVersionVector& versions) {
     supported_versions_ = versions;
     quic_version_ = versions[0];
   }
 
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
   Perspective perspective() const { return perspective_; }
 
-  // Called when a PATH_CLOSED frame has been sent/received on |path_id|.
-  void OnPathClosed(QuicPathId path_id);
-
   QuicTag last_version_tag() { return last_version_tag_; }
 
  private:
   friend class test::QuicFramerPeer;
 
   typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
 
   struct AckFrameInfo {
     AckFrameInfo();
     AckFrameInfo(const AckFrameInfo& other);
@@ skipping 52 matching lines @@
   bool ProcessBlockedFrame(QuicDataReader* reader, QuicBlockedFrame* frame);
   bool ProcessPathCloseFrame(QuicDataReader* reader, QuicPathCloseFrame* frame);
 
   bool DecryptPayload(QuicDataReader* encrypted_reader,
                       const QuicPacketHeader& header,
                       const QuicEncryptedPacket& packet,
                       char* decrypted_buffer,
                       size_t buffer_length,
                       size_t* decrypted_length);
 
-  // Checks if |path_id| is a viable path to receive packets on. Returns true
-  // and sets |base_packet_number| to the packet number to calculate the
-  // incoming packet number from if the path is not closed. Returns false
-  // otherwise.
-  bool IsValidPath(QuicPathId path_id, QuicPacketNumber* base_packet_number);
-
   // Sets last_packet_number_. This can only be called after the packet is
   // successfully decrypted.
   void SetLastPacketNumber(const QuicPacketHeader& header);
 
   // Returns the full packet number from the truncated
   // wire format version and the last seen packet number.
   QuicPacketNumber CalculatePacketNumberFromWire(
       QuicPacketNumberLength packet_number_length,
       QuicPacketNumber base_packet_number,
       QuicPacketNumber packet_number) const;
@@ skipping 58 matching lines @@
 
   bool RaiseError(QuicErrorCode error);
 
   void set_error(QuicErrorCode error) { error_ = error; }
 
   void set_detailed_error(const char* error) { detailed_error_ = error; }
 
   std::string detailed_error_;
   QuicFramerVisitorInterface* visitor_;
   QuicErrorCode error_;
-  // Set of closed paths. A path is considered as closed if a PATH_CLOSED frame
-  // has been sent/received.
-  // TODO(fayang): this set is never cleaned up. A possible improvement is to
-  // use intervals.
-  std::unordered_set<QuicPathId> closed_paths_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketNumber last_packet_number_;
-  // Map mapping path id to packet number of largest successfully decrypted
-  // received packet.
-  std::unordered_map<QuicPathId, QuicPacketNumber> largest_packet_numbers_;
   // Updated by ProcessPacketHeader when it succeeds decrypting a larger packet.
   QuicPacketNumber largest_packet_number_;
-  // The path on which last successfully decrypted packet was received.
-  QuicPathId last_path_id_;
   // Updated by WritePacketHeader.
   QuicConnectionId last_serialized_connection_id_;
   // The last QUIC version tag received.
   QuicTag last_version_tag_;
   // Version of the protocol being used.
   QuicVersion quic_version_;
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
   // element, with subsequent elements in descending order (versions can be
   // skipped as necessary).
@@ skipping 25 matching lines @@
   QuicTime::Delta last_timestamp_;
   // The diversification nonce from the last received packet.
   DiversificationNonce last_nonce_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_FRAMER_H_