Sync from Piper @310858019

PROTOBUF_SYNC_PIPER

Author: haberman

experimental/runtime/kernel/conformance/conformance_testee.js

@@ -8,7 +8,8 @@ const BinaryStorage = goog.require('protobuf.runtime.BinaryStorage');
 const BufferDecoder = goog.require('protobuf.binary.BufferDecoder');
 const WireType = goog.require('protobuf.binary.WireType');
 const {Field} = goog.require('protobuf.binary.field');
-const {checkCriticalElementIndex, checkCriticalState} = goog.require('protobuf.internal.checks');
+const {checkCriticalState} = goog.require('protobuf.internal.checks');
+const {skipField, tagToFieldNumber, tagToWireType} = goog.require('protobuf.binary.tag');
 
 /**
  * Appends a new entry in the index array for the given field number.
@@ -26,26 +27,6 @@ function addIndexEntry(storage, fieldNumber, wireType, startIndex) {
   }
 }
 
-/**
- * Returns wire type stored in a tag.
- * Protos store the wire type as the first 3 bit of a tag.
- * @param {number} tag
- * @return {!WireType}
- */
-function tagToWireType(tag) {
-  return /** @type {!WireType} */ (tag & 0x07);
-}
-
-/**
- * Returns the field number stored in a tag.
- * Protos store the field number in the upper 29 bits of a 32 bit number.
- * @param {number} tag
- * @return {number}
- */
-function tagToFieldNumber(tag) {
-  return tag >>> 3;
-}
-
 /**
  * Creates an index of field locations in a given binary protobuf.
  * @param {!BufferDecoder} bufferDecoder
@@ -62,83 +43,13 @@ function buildIndex(bufferDecoder, pivot) {
     const wireType = tagToWireType(tag);
     const fieldNumber = tagToFieldNumber(tag);
     checkCriticalState(fieldNumber > 0, `Invalid field number ${fieldNumber}`);
-
     addIndexEntry(storage, fieldNumber, wireType, bufferDecoder.cursor());
-
-    checkCriticalState(
-        !skipField_(bufferDecoder, wireType, fieldNumber),
-        'Found unmatched stop group.');
+    skipField(bufferDecoder, wireType, fieldNumber);
   }
   return storage;
 }
 
-/**
- * Skips over fields until the next field of the message.
- * @param {!BufferDecoder} bufferDecoder
- * @param {!WireType} wireType
- * @param {number} fieldNumber
- * @return {boolean} Whether the field we skipped over was a stop group.
- * @private
- */
-function skipField_(bufferDecoder, wireType, fieldNumber) {
-  switch (wireType) {
-    case WireType.VARINT:
-      checkCriticalElementIndex(
-          bufferDecoder.cursor(), bufferDecoder.endIndex());
-      bufferDecoder.skipVarint();
-      return false;
-    case WireType.FIXED64:
-      bufferDecoder.skip(8);
-      return false;
-    case WireType.DELIMITED:
-      checkCriticalElementIndex(
-          bufferDecoder.cursor(), bufferDecoder.endIndex());
-      const length = bufferDecoder.getUnsignedVarint32();
-      bufferDecoder.skip(length);
-      return false;
-    case WireType.START_GROUP:
-      checkCriticalState(
-          skipGroup_(bufferDecoder, fieldNumber), 'No end group found.');
-      return false;
-    case WireType.END_GROUP:
-      // Signal that we found a stop group to the caller
-      return true;
-    case WireType.FIXED32:
-      bufferDecoder.skip(4);
-      return false;
-    default:
-      throw new Error(`Invalid wire type: ${wireType}`);
-  }
-}
-
-/**
- * Skips over fields until it finds the end of a given group.
- * @param {!BufferDecoder} bufferDecoder
- * @param {number} groupFieldNumber
- * @return {boolean} Returns true if an end was found.
- * @private
- */
-function skipGroup_(bufferDecoder, groupFieldNumber) {
-  // On a start group we need to keep skipping fields until we find a
-  // corresponding stop group
-  // Note: Since we are calling skipField from here nested groups will be
-  // handled by recursion of this method and thus we will not see a nested
-  // STOP GROUP here unless there is something wrong with the input data.
-  while (bufferDecoder.hasNext()) {
-    const tag = bufferDecoder.getUnsignedVarint32();
-    const wireType = tagToWireType(tag);
-    const fieldNumber = tagToFieldNumber(tag);
-
-    if (skipField_(bufferDecoder, wireType, fieldNumber)) {
-      checkCriticalState(
-          groupFieldNumber === fieldNumber,
-          `Expected stop group for fieldnumber ${groupFieldNumber} not found.`);
-      return true;
-    }
-  }
-  return false;
-}
-
 exports = {
   buildIndex,
+  tagToWireType,
 };

experimental/runtime/kernel/conformance/conformance_testee_runner_node.js

@@ -72,12 +72,12 @@ describe('Indexer does', () => {
 
   it('fail for invalid wire type (6)', () => {
     expect(() => buildIndex(createBufferDecoder(0x0E, 0x01), PIVOT))
-        .toThrowError('Invalid wire type: 6');
+        .toThrowError('Unexpected wire type: 6');
   });
 
   it('fail for invalid wire type (7)', () => {
     expect(() => buildIndex(createBufferDecoder(0x0F, 0x01), PIVOT))
-        .toThrowError('Invalid wire type: 7');
+        .toThrowError('Unexpected wire type: 7');
   });
 
   it('index varint', () => {
@@ -269,33 +269,8 @@ describe('Indexer does', () => {
 
   it('fail on unmatched stop group', () => {
     const data = createBufferDecoder(0x0C, 0x01);
-    if (CHECK_CRITICAL_STATE) {
-      expect(() => buildIndex(data, PIVOT))
-          .toThrowError('Found unmatched stop group.');
-    } else {
-      // Note in unchecked mode we produce invalid output for invalid inputs.
-      // This test just documents our behavior in those cases.
-      // These values might change at any point and are not considered
-      // what the implementation should be doing here.
-      const storage = buildIndex(data, PIVOT);
-
-      expect(getStorageSize(storage)).toBe(1);
-      const entryArray = storage.get(1).getIndexArray();
-      expect(entryArray).not.toBeUndefined();
-      expect(entryArray.length).toBe(1);
-      const entry = entryArray[0];
-
-      expect(Field.getWireType(entry)).toBe(WireType.END_GROUP);
-      expect(Field.getStartIndex(entry)).toBe(1);
-
-      const entryArray2 = storage.get(0).getIndexArray();
-      expect(entryArray2).not.toBeUndefined();
-      expect(entryArray2.length).toBe(1);
-      const entry2 = entryArray2[0];
-
-      expect(Field.getWireType(entry2)).toBe(WireType.FIXED64);
-      expect(Field.getStartIndex(entry2)).toBe(2);
-    }
+    expect(() => buildIndex(data, PIVOT))
+        .toThrowError('Unexpected wire type: 4');
   });
 
   it('fail for groups without matching stop group', () => {