OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef NET_SPDY_HPACK_HEADER_TABLE_H_ | |
6 #define NET_SPDY_HPACK_HEADER_TABLE_H_ | |
7 | |
8 #include <cstddef> | |
9 #include <deque> | |
10 #include <set> | |
11 | |
12 #include "base/basictypes.h" | |
13 #include "base/macros.h" | |
14 #include "net/base/net_export.h" | |
15 #include "net/spdy/hpack_entry.h" | |
16 | |
17 // All section references below are to | |
18 // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-08 | |
19 | |
20 namespace net { | |
21 | |
22 using base::StringPiece; | |
23 | |
24 namespace test { | |
25 class HpackHeaderTablePeer; | |
26 } // namespace test | |
27 | |
28 // A data structure for the static table (3.3.1) and the header table (3.3.2). | |
29 class NET_EXPORT_PRIVATE HpackHeaderTable { | |
30 public: | |
31 friend class test::HpackHeaderTablePeer; | |
32 | |
33 // HpackHeaderTable takes advantage of the deque property that references | |
34 // remain valid, so long as insertions & deletions are at the head & tail. | |
35 // If this changes (eg we start to drop entries from the middle of the table), | |
36 // this needs to be a std::list, in which case |*_index_| can be trivially | |
37 // extended to map to list iterators. | |
38 typedef std::deque<HpackEntry> EntryTable; | |
39 | |
40 // Implements a total ordering of HpackEntry on name(), value(), then index | |
41 // ascending. Note that index may change over the lifetime of an HpackEntry, | |
42 // but the relative index order of two entries will not. This comparator is | |
43 // composed with the 'lookup' HpackEntry constructor to allow for efficient | |
44 // lower-bounding of matching entries. | |
45 struct NET_EXPORT_PRIVATE EntryComparator { | |
46 bool operator() (const HpackEntry* lhs, const HpackEntry* rhs) const; | |
47 }; | |
48 typedef std::set<HpackEntry*, EntryComparator> OrderedEntrySet; | |
49 | |
50 HpackHeaderTable(); | |
51 | |
52 ~HpackHeaderTable(); | |
53 | |
54 // Last-aknowledged value of SETTINGS_HEADER_TABLE_SIZE. | |
55 size_t settings_size_bound() { return settings_size_bound_; } | |
56 | |
57 // Current and maximum estimated byte size of the table, as described in | |
58 // 5.1. Notably, this is /not/ the number of entries in the table. | |
59 size_t size() const { return size_; } | |
60 size_t max_size() const { return max_size_; } | |
61 | |
62 // Returns the entry matching the index, or NULL. | |
63 const HpackEntry* GetByIndex(size_t index); | |
64 | |
65 // Returns the lowest-value entry having |name|, or NULL. | |
66 const HpackEntry* GetByName(StringPiece name); | |
67 | |
68 // Returns the lowest-index matching entry, or NULL. | |
69 const HpackEntry* GetByNameAndValue(StringPiece name, StringPiece value); | |
70 | |
71 // Returns the index of an entry within this header table. | |
72 size_t IndexOf(const HpackEntry* entry) const; | |
73 | |
74 // Sets the maximum size of the header table, evicting entries if | |
75 // necessary as described in 5.2. | |
76 void SetMaxSize(size_t max_size); | |
77 | |
78 // Sets the SETTINGS_HEADER_TABLE_SIZE bound of the table. Will call | |
79 // SetMaxSize() as needed to preserve max_size() <= settings_size_bound(). | |
80 void SetSettingsHeaderTableSize(size_t settings_size); | |
81 | |
82 // Determine the set of entries which would be evicted by the insertion | |
83 // of |name| & |value| into the table, as per section 3.3.3. No eviction | |
84 // actually occurs. The set is returned via range [begin_out, end_out). | |
85 void EvictionSet(StringPiece name, | |
86 StringPiece value, | |
87 EntryTable::iterator* begin_out, | |
88 EntryTable::iterator* end_out); | |
89 | |
90 // Adds an entry for the representation, evicting entries as needed. |name| | |
91 // and |value| must not be owned by an entry which could be evicted. The | |
92 // added HpackEntry is returned, or NULL is returned if all entries were | |
93 // evicted and the empty table is of insufficent size for the representation. | |
94 const HpackEntry* TryAddEntry(StringPiece name, StringPiece value); | |
95 | |
96 void DebugLogTableState() const; | |
97 | |
98 private: | |
99 // Returns number of evictions required to enter |name| & |value|. | |
100 size_t EvictionCountForEntry(StringPiece name, StringPiece value) const; | |
101 | |
102 // Returns number of evictions required to reclaim |reclaim_size| table size. | |
103 size_t EvictionCountToReclaim(size_t reclaim_size) const; | |
104 | |
105 // Evicts |count| oldest entries from the table. | |
106 void Evict(size_t count); | |
107 | |
108 // |static_entries_| and |static_index_| are owned by HpackStaticTable | |
109 // singleton. | |
110 const EntryTable& static_entries_; | |
111 EntryTable dynamic_entries_; | |
112 | |
113 const OrderedEntrySet& static_index_; | |
114 OrderedEntrySet dynamic_index_; | |
115 | |
116 // Last acknowledged value for SETTINGS_HEADER_TABLE_SIZE. | |
117 size_t settings_size_bound_; | |
118 | |
119 // Estimated current and maximum byte size of the table. | |
120 // |max_size_| <= |settings_header_table_size_| | |
121 size_t size_; | |
122 size_t max_size_; | |
123 | |
124 // Total number of table insertions which have occurred. Referenced by | |
125 // IndexOf() for determination of an HpackEntry's table index. | |
126 size_t total_insertions_; | |
127 | |
128 DISALLOW_COPY_AND_ASSIGN(HpackHeaderTable); | |
129 }; | |
130 | |
131 } // namespace net | |
132 | |
133 #endif // NET_SPDY_HPACK_HEADER_TABLE_H_ | |
OLD | NEW |