Update containerd to ec15fe95aa.

Signed-off-by: Lantao Liu <lantaol@google.com>

vendor/github.com/json-iterator/go/feature_config.go

@@ -48,7 +48,6 @@ type API interface {
 	NewEncoder(writer io.Writer) *Encoder
 	NewDecoder(reader io.Reader) *Decoder
 	Valid(data []byte) bool
-	RegisterExtension(extension Extension)
 }
 
 // ConfigDefault the default API
@@ -133,7 +132,7 @@ func (cfg *frozenConfig) getTagKey() string {
 	return tagKey
 }
 
-func (cfg *frozenConfig) RegisterExtension(extension Extension) {
+func (cfg *frozenConfig) registerExtension(extension Extension) {
 	cfg.extensions = append(cfg.extensions, extension)
 }
 

vendor/github.com/json-iterator/go/feature_iter_int.go

@@ -113,9 +113,13 @@ func (iter *Iterator) ReadUint32() (ret uint32) {
 }
 
 func (iter *Iterator) readUint32(c byte) (ret uint32) {
+	defer func() {
+		if iter.head < len(iter.buf) && iter.buf[iter.head] == '.' {
+			iter.ReportError("readUint32", "can not decode float as int")
+		}
+	}()
 	ind := intDigits[c]
 	if ind == 0 {
-		iter.assertInteger()
 		return 0 // single zero
 	}
 	if ind == invalidCharForNumber {
@@ -128,14 +132,12 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		ind2 := intDigits[iter.buf[i]]
 		if ind2 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value
 		}
 		i++
 		ind3 := intDigits[iter.buf[i]]
 		if ind3 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value*10 + uint32(ind2)
 		}
 		//iter.head = i + 1
@@ -144,35 +146,30 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		ind4 := intDigits[iter.buf[i]]
 		if ind4 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value*100 + uint32(ind2)*10 + uint32(ind3)
 		}
 		i++
 		ind5 := intDigits[iter.buf[i]]
 		if ind5 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value*1000 + uint32(ind2)*100 + uint32(ind3)*10 + uint32(ind4)
 		}
 		i++
 		ind6 := intDigits[iter.buf[i]]
 		if ind6 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value*10000 + uint32(ind2)*1000 + uint32(ind3)*100 + uint32(ind4)*10 + uint32(ind5)
 		}
 		i++
 		ind7 := intDigits[iter.buf[i]]
 		if ind7 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value*100000 + uint32(ind2)*10000 + uint32(ind3)*1000 + uint32(ind4)*100 + uint32(ind5)*10 + uint32(ind6)
 		}
 		i++
 		ind8 := intDigits[iter.buf[i]]
 		if ind8 == invalidCharForNumber {
 			iter.head = i
-			iter.assertInteger()
 			return value*1000000 + uint32(ind2)*100000 + uint32(ind3)*10000 + uint32(ind4)*1000 + uint32(ind5)*100 + uint32(ind6)*10 + uint32(ind7)
 		}
 		i++
@@ -180,7 +177,6 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		value = value*10000000 + uint32(ind2)*1000000 + uint32(ind3)*100000 + uint32(ind4)*10000 + uint32(ind5)*1000 + uint32(ind6)*100 + uint32(ind7)*10 + uint32(ind8)
 		iter.head = i
 		if ind9 == invalidCharForNumber {
-			iter.assertInteger()
 			return value
 		}
 	}
@@ -189,7 +185,6 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 			ind = intDigits[iter.buf[i]]
 			if ind == invalidCharForNumber {
 				iter.head = i
-				iter.assertInteger()
 				return value
 			}
 			if value > uint32SafeToMultiply10 {
@@ -204,7 +199,6 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 			value = (value << 3) + (value << 1) + uint32(ind)
 		}
 		if !iter.loadMore() {
-			iter.assertInteger()
 			return value
 		}
 	}
@@ -235,9 +229,13 @@ func (iter *Iterator) ReadUint64() uint64 {
 }
 
 func (iter *Iterator) readUint64(c byte) (ret uint64) {
+	defer func() {
+		if iter.head < len(iter.buf) && iter.buf[iter.head] == '.' {
+			iter.ReportError("readUint64", "can not decode float as int")
+		}
+	}()
 	ind := intDigits[c]
 	if ind == 0 {
-		iter.assertInteger()
 		return 0 // single zero
 	}
 	if ind == invalidCharForNumber {
@@ -245,73 +243,11 @@ func (iter *Iterator) readUint64(c byte) (ret uint64) {
 		return
 	}
 	value := uint64(ind)
-	if iter.tail-iter.head > 10 {
-		i := iter.head
-		ind2 := intDigits[iter.buf[i]]
-		if ind2 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value
-		}
-		i++
-		ind3 := intDigits[iter.buf[i]]
-		if ind3 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value*10 + uint64(ind2)
-		}
-		//iter.head = i + 1
-		//value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
-		i++
-		ind4 := intDigits[iter.buf[i]]
-		if ind4 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value*100 + uint64(ind2)*10 + uint64(ind3)
-		}
-		i++
-		ind5 := intDigits[iter.buf[i]]
-		if ind5 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value*1000 + uint64(ind2)*100 + uint64(ind3)*10 + uint64(ind4)
-		}
-		i++
-		ind6 := intDigits[iter.buf[i]]
-		if ind6 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value*10000 + uint64(ind2)*1000 + uint64(ind3)*100 + uint64(ind4)*10 + uint64(ind5)
-		}
-		i++
-		ind7 := intDigits[iter.buf[i]]
-		if ind7 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value*100000 + uint64(ind2)*10000 + uint64(ind3)*1000 + uint64(ind4)*100 + uint64(ind5)*10 + uint64(ind6)
-		}
-		i++
-		ind8 := intDigits[iter.buf[i]]
-		if ind8 == invalidCharForNumber {
-			iter.head = i
-			iter.assertInteger()
-			return value*1000000 + uint64(ind2)*100000 + uint64(ind3)*10000 + uint64(ind4)*1000 + uint64(ind5)*100 + uint64(ind6)*10 + uint64(ind7)
-		}
-		i++
-		ind9 := intDigits[iter.buf[i]]
-		value = value*10000000 + uint64(ind2)*1000000 + uint64(ind3)*100000 + uint64(ind4)*10000 + uint64(ind5)*1000 + uint64(ind6)*100 + uint64(ind7)*10 + uint64(ind8)
-		iter.head = i
-		if ind9 == invalidCharForNumber {
-			iter.assertInteger()
-			return value
-		}
-	}
 	for {
 		for i := iter.head; i < iter.tail; i++ {
 			ind = intDigits[iter.buf[i]]
 			if ind == invalidCharForNumber {
 				iter.head = i
-				iter.assertInteger()
 				return value
 			}
 			if value > uint64SafeToMultiple10 {
@@ -326,14 +262,7 @@ func (iter *Iterator) readUint64(c byte) (ret uint64) {
 			value = (value << 3) + (value << 1) + uint64(ind)
 		}
 		if !iter.loadMore() {
-			iter.assertInteger()
 			return value
 		}
 	}
 }
-
-func (iter *Iterator) assertInteger() {
-	if iter.head < len(iter.buf) && iter.buf[iter.head] == '.' {
-		iter.ReportError("assertInteger", "can not decode float as int")
-	}
-}

vendor/github.com/json-iterator/go/feature_reflect.go

@@ -274,7 +274,7 @@ func decoderOfType(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
 	if decoder != nil {
 		return decoder, nil
 	}
-	decoder = getTypeDecoderFromExtension(cfg, typ)
+	decoder = getTypeDecoderFromExtension(typ)
 	if decoder != nil {
 		cfg.addDecoderToCache(cacheKey, decoder)
 		return decoder, nil
@@ -285,9 +285,6 @@ func decoderOfType(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
 	for _, extension := range extensions {
 		decoder = extension.DecorateDecoder(typ, decoder)
 	}
-	for _, extension := range cfg.extensions {
-		decoder = extension.DecorateDecoder(typ, decoder)
-	}
 	cfg.addDecoderToCache(cacheKey, decoder)
 	return decoder, err
 }
@@ -444,7 +441,7 @@ func encoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
 	if encoder != nil {
 		return encoder, nil
 	}
-	encoder = getTypeEncoderFromExtension(cfg, typ)
+	encoder = getTypeEncoderFromExtension(typ)
 	if encoder != nil {
 		cfg.addEncoderToCache(cacheKey, encoder)
 		return encoder, nil
@@ -455,9 +452,6 @@ func encoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
 	for _, extension := range extensions {
 		encoder = extension.DecorateEncoder(typ, encoder)
 	}
-	for _, extension := range cfg.extensions {
-		encoder = extension.DecorateEncoder(typ, encoder)
-	}
 	cfg.addEncoderToCache(cacheKey, encoder)
 	return encoder, err
 }
@@ -476,7 +470,7 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error
 		return &jsoniterNumberCodec{}, nil
 	}
 	if typ.Implements(marshalerType) {
-		checkIsEmpty, err := createCheckIsEmpty(cfg, typ)
+		checkIsEmpty, err := createCheckIsEmpty(typ)
 		if err != nil {
 			return nil, err
 		}
@@ -491,7 +485,7 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error
 		return encoder, nil
 	}
 	if reflect.PtrTo(typ).Implements(marshalerType) {
-		checkIsEmpty, err := createCheckIsEmpty(cfg, reflect.PtrTo(typ))
+		checkIsEmpty, err := createCheckIsEmpty(reflect.PtrTo(typ))
 		if err != nil {
 			return nil, err
 		}
@@ -503,7 +497,7 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error
 		return encoder, nil
 	}
 	if typ.Implements(textMarshalerType) {
-		checkIsEmpty, err := createCheckIsEmpty(cfg, typ)
+		checkIsEmpty, err := createCheckIsEmpty(typ)
 		if err != nil {
 			return nil, err
 		}
@@ -526,7 +520,7 @@ func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error
 	return createEncoderOfSimpleType(cfg, typ)
 }
 
-func createCheckIsEmpty(cfg *frozenConfig, typ reflect.Type) (checkIsEmpty, error) {
+func createCheckIsEmpty(typ reflect.Type) (checkIsEmpty, error) {
 	kind := typ.Kind()
 	switch kind {
 	case reflect.String:
@@ -571,7 +565,7 @@ func createCheckIsEmpty(cfg *frozenConfig, typ reflect.Type) (checkIsEmpty, erro
 	case reflect.Slice:
 		return &sliceEncoder{}, nil
 	case reflect.Map:
-		return encoderOfMap(cfg, typ)
+		return &mapEncoder{}, nil
 	case reflect.Ptr:
 		return &OptionalEncoder{}, nil
 	default:

vendor/github.com/json-iterator/go/feature_reflect_extension.go

@@ -161,31 +161,22 @@ func RegisterExtension(extension Extension) {
 	extensions = append(extensions, extension)
 }
 
-func getTypeDecoderFromExtension(cfg *frozenConfig, typ reflect.Type) ValDecoder {
-	decoder := _getTypeDecoderFromExtension(cfg, typ)
+func getTypeDecoderFromExtension(typ reflect.Type) ValDecoder {
+	decoder := _getTypeDecoderFromExtension(typ)
 	if decoder != nil {
 		for _, extension := range extensions {
 			decoder = extension.DecorateDecoder(typ, decoder)
 		}
-		for _, extension := range cfg.extensions {
-			decoder = extension.DecorateDecoder(typ, decoder)
-		}
 	}
 	return decoder
 }
-func _getTypeDecoderFromExtension(cfg *frozenConfig, typ reflect.Type) ValDecoder {
+func _getTypeDecoderFromExtension(typ reflect.Type) ValDecoder {
 	for _, extension := range extensions {
 		decoder := extension.CreateDecoder(typ)
 		if decoder != nil {
 			return decoder
 		}
 	}
-	for _, extension := range cfg.extensions {
-		decoder := extension.CreateDecoder(typ)
-		if decoder != nil {
-			return decoder
-		}
-	}
 	typeName := typ.String()
 	decoder := typeDecoders[typeName]
 	if decoder != nil {
@@ -200,32 +191,23 @@ func _getTypeDecoderFromExtension(cfg *frozenConfig, typ reflect.Type) ValDecode
 	return nil
 }
 
-func getTypeEncoderFromExtension(cfg *frozenConfig, typ reflect.Type) ValEncoder {
-	encoder := _getTypeEncoderFromExtension(cfg, typ)
+func getTypeEncoderFromExtension(typ reflect.Type) ValEncoder {
+	encoder := _getTypeEncoderFromExtension(typ)
 	if encoder != nil {
 		for _, extension := range extensions {
 			encoder = extension.DecorateEncoder(typ, encoder)
 		}
-		for _, extension := range cfg.extensions {
-			encoder = extension.DecorateEncoder(typ, encoder)
-		}
 	}
 	return encoder
 }
 
-func _getTypeEncoderFromExtension(cfg *frozenConfig, typ reflect.Type) ValEncoder {
+func _getTypeEncoderFromExtension(typ reflect.Type) ValEncoder {
 	for _, extension := range extensions {
 		encoder := extension.CreateEncoder(typ)
 		if encoder != nil {
 			return encoder
 		}
 	}
-	for _, extension := range cfg.extensions {
-		encoder := extension.CreateEncoder(typ)
-		if encoder != nil {
-			return encoder
-		}
-	}
 	typeName := typ.String()
 	encoder := typeEncoders[typeName]
 	if encoder != nil {
@@ -342,9 +324,6 @@ func createStructDescriptor(cfg *frozenConfig, typ reflect.Type, bindings []*Bin
 	for _, extension := range extensions {
 		extension.UpdateStructDescriptor(structDescriptor)
 	}
-	for _, extension := range cfg.extensions {
-		extension.UpdateStructDescriptor(structDescriptor)
-	}
 	processTags(structDescriptor, cfg)
 	// merge normal & embedded bindings & sort with original order
 	allBindings := sortableBindings(append(embeddedBindings, structDescriptor.Fields...))