[qpack] Overhaul the pseudocode (#3577)

* [qpack] Overhaul the pseudocode

* Use the current terminology (insert count, base, encoder stream)
* Update to current design (modulo encoding of RIC)
* Normalize naming: index vs. idx
* Comments

Fixes #3544

* Fix lint

* Martin's feedback

draft-ietf-quic-qpack.md

@@ -1535,54 +1535,62 @@ smallest number of bytes.
 # Sample One Pass Encoding Algorithm
 
 Pseudo-code for single pass encoding, excluding handling of duplicates,
-non-blocking mode, and reference tracking.
+non-blocking mode, available encoder stream flow control and reference tracking.
 
 ~~~
-baseIndex = dynamicTable.baseIndex
-largestReference = 0
+base = dynamicTable.getInsertCount()
+requiredInsertCount = 0
 for header in headers:
-  staticIdx = staticTable.getIndex(header)
-  if staticIdx:
-    encodeIndexReference(streamBuffer, staticIdx)
+  staticIndex = staticTable.findIndex(header)
+  if staticIndex is not None:
+    encodeIndexReference(streamBuffer, staticIndex)
     continue
 
-  dynamicIdx = dynamicTable.getIndex(header)
-  if !dynamicIdx:
+  dynamicIndex = dynamicTable.findIndex(header)
+  if dynamicIndex is None:
     # No matching entry.  Either insert+index or encode literal
-    nameIdx = getNameIndex(header)
+    staticNameIndex = staticTable.findName(header.name)
+    if staticNameIndex is None:
+       dynamicNameIndex = dynamicTable.findName(header.name)
+
     if shouldIndex(header) and dynamicTable.canIndex(header):
-      encodeLiteralWithIncrementalIndex(controlBuffer, nameIdx,
-                                        header)
-      dynamicTable.add(header)
-      dynamicIdx = dynamicTable.baseIndex
+      encodeInsert(encoderBuffer, staticNameIndex,
+                   dynamicNameIndex, header)
+      dynamicIndex = dynamicTable.add(header)
 
-  if !dynamicIdx:
+  if dynamicIndex is None:
     # Couldn't index it, literal
-    if nameIdx <= staticTable.size:
+    if nameIndex is None or isStaticName:
+      # Encodes a literal with a static name or literal name
       encodeLiteral(streamBuffer, nameIndex, header)
     else:
-      # encode literal, possibly with nameIdx above baseIndex
-      encodeDynamicLiteral(streamBuffer, nameIndex, baseIndex,
-                           header)
-      largestReference = max(largestReference,
-                             dynamicTable.toAbsolute(nameIdx))
+      # encode literal with dynamic name, possibly above base
+      encodeDynamicLiteral(streamBuffer, nameIndex, base, header)
+      requiredInsertCount = max(requiredInsertCount, nameIndex)
   else:
     # Dynamic index reference
-    assert(dynamicIdx)
-    largestReference = max(largestReference, dynamicIdx)
-    # Encode dynamicIdx, possibly with dynamicIdx above baseIndex
-    encodeDynamicIndexReference(streamBuffer, dynamicIdx,
-                                baseIndex)
+    assert(dynamicIndex is not None)
+    requiredInsertCount = max(requiredInsertCount, dynamicIndex)
+    # Encode dynamicIndex, possibly above base
+    encodeDynamicIndexReference(streamBuffer, dynamicIndex, base)
 
 # encode the prefix
-encodeInteger(prefixBuffer, 0x00, largestReference, 8)
-if baseIndex >= largestReference:
-  encodeInteger(prefixBuffer, 0, baseIndex - largestReference, 7)
+if requiredInsertCount == 0:
+  encodeIndexReference(prefixBuffer, 0, 0, 8)
+  encodeIndexReference(prefixBuffer, 0, 0, 7)
 else:
-  encodeInteger(prefixBuffer, 0x80,
-                largestReference  - baseIndex, 7)
+  wireRIC = (
+    requiredInsertCount
+    % (2 * getMaxEntries(maxTableCapacity))
+  ) + 1;
+  encodeInteger(prefixBuffer, 0x00, wireRIC, 8)
+  if base >= requiredInsertCount:
+    encodeInteger(prefixBuffer, 0, base - requiredInsertCount, 7)
+  else:
+    encodeInteger(prefixBuffer, 0x80,
+                  requiredInsertCount  - base - 1, 7)
 
-return controlBuffer, prefixBuffer + streamBuffer
+return encoderBuffer, prefixBuffer + streamBuffer
 ~~~
 
 # Change Log