11 files changed, 244 insertions, 244 deletions

diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
index d9aa3c4..63b0f08 100644
--- a/vendor/github.com/golang/protobuf/proto/decode.go
+++ b/vendor/github.com/golang/protobuf/proto/decode.go
@@ -186,7 +186,6 @@ func (p *Buffer) DecodeVarint() (x uint64, err error) {
         if b&0x80 == 0 {
                 goto done
         }
-        // x -= 0x80 << 63 // Always zero.
 
         return 0, errOverflow
 
diff --git a/vendor/github.com/golang/protobuf/proto/deprecated.go b/vendor/github.com/golang/protobuf/proto/deprecated.go
new file mode 100644
index 0000000..35b882c
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/deprecated.go
@@ -0,0 +1,63 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2018 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import "errors"
+
+// Deprecated: do not use.
+type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
+
+// Deprecated: do not use.
+func GetStats() Stats { return Stats{} }
+
+// Deprecated: do not use.
+func MarshalMessageSet(interface{}) ([]byte, error) {
+        return nil, errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func UnmarshalMessageSet([]byte, interface{}) error {
+        return errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func MarshalMessageSetJSON(interface{}) ([]byte, error) {
+        return nil, errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func UnmarshalMessageSetJSON([]byte, interface{}) error {
+        return errors.New("proto: not implemented")
+}
+
+// Deprecated: do not use.
+func RegisterMessageSetType(Message, int32, string) {}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
index d4db5a1..f9b6e41 100644
--- a/vendor/github.com/golang/protobuf/proto/equal.go
+++ b/vendor/github.com/golang/protobuf/proto/equal.go
@@ -246,7 +246,8 @@ func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
                         return false
                 }
 
-                m1, m2 := e1.value, e2.value
+                m1 := extensionAsLegacyType(e1.value)
+                m2 := extensionAsLegacyType(e2.value)
 
                 if m1 == nil && m2 == nil {
                         // Both have only encoded form.
diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
index 816a3b9..fa88add 100644
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -185,9 +185,25 @@ type Extension struct {
         // extension will have only enc set. When such an extension is
         // accessed using GetExtension (or GetExtensions) desc and value
         // will be set.
-        desc  *ExtensionDesc
+        desc *ExtensionDesc
+
+        // value is a concrete value for the extension field. Let the type of
+        // desc.ExtensionType be the "API type" and the type of Extension.value
+        // be the "storage type". The API type and storage type are the same except:
+        //      * For scalars (except []byte), the API type uses *T,
+        //      while the storage type uses T.
+        //      * For repeated fields, the API type uses []T, while the storage type
+        //      uses *[]T.
+        //
+        // The reason for the divergence is so that the storage type more naturally
+        // matches what is expected of when retrieving the values through the
+        // protobuf reflection APIs.
+        //
+        // The value may only be populated if desc is also populated.
         value interface{}
-        enc   []byte
+
+        // enc is the raw bytes for the extension field.
+        enc []byte
 }
 
 // SetRawExtension is for testing only.
@@ -334,7 +350,7 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
                         // descriptors with the same field number.
                         return nil, errors.New("proto: descriptor conflict")
                 }
-                return e.value, nil
+                return extensionAsLegacyType(e.value), nil
         }
 
         if extension.ExtensionType == nil {
@@ -349,11 +365,11 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
 
         // Remember the decoded version and drop the encoded version.
         // That way it is safe to mutate what we return.
-        e.value = v
+        e.value = extensionAsStorageType(v)
         e.desc = extension
         e.enc = nil
         emap[extension.Field] = e
-        return e.value, nil
+        return extensionAsLegacyType(e.value), nil
 }
 
 // defaultExtensionValue returns the default value for extension.
@@ -488,7 +504,7 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
         }
         typ := reflect.TypeOf(extension.ExtensionType)
         if typ != reflect.TypeOf(value) {
-                return errors.New("proto: bad extension value type")
+                return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
         }
         // nil extension values need to be caught early, because the
         // encoder can't distinguish an ErrNil due to a nil extension
@@ -500,7 +516,7 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
         }
 
         extmap := epb.extensionsWrite()
-        extmap[extension.Field] = Extension{desc: extension, value: value}
+        extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
         return nil
 }
 
@@ -541,3 +557,51 @@ func RegisterExtension(desc *ExtensionDesc) {
 func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
         return extensionMaps[reflect.TypeOf(pb).Elem()]
 }
+
+// extensionAsLegacyType converts an value in the storage type as the API type.
+// See Extension.value.
+func extensionAsLegacyType(v interface{}) interface{} {
+        switch rv := reflect.ValueOf(v); rv.Kind() {
+        case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+                // Represent primitive types as a pointer to the value.
+                rv2 := reflect.New(rv.Type())
+                rv2.Elem().Set(rv)
+                v = rv2.Interface()
+        case reflect.Ptr:
+                // Represent slice types as the value itself.
+                switch rv.Type().Elem().Kind() {
+                case reflect.Slice:
+                        if rv.IsNil() {
+                                v = reflect.Zero(rv.Type().Elem()).Interface()
+                        } else {
+                                v = rv.Elem().Interface()
+                        }
+                }
+        }
+        return v
+}
+
+// extensionAsStorageType converts an value in the API type as the storage type.
+// See Extension.value.
+func extensionAsStorageType(v interface{}) interface{} {
+        switch rv := reflect.ValueOf(v); rv.Kind() {
+        case reflect.Ptr:
+                // Represent slice types as the value itself.
+                switch rv.Type().Elem().Kind() {
+                case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+                        if rv.IsNil() {
+                                v = reflect.Zero(rv.Type().Elem()).Interface()
+                        } else {
+                                v = rv.Elem().Interface()
+                        }
+                }
+        case reflect.Slice:
+                // Represent slice types as a pointer to the value.
+                if rv.Type().Elem().Kind() != reflect.Uint8 {
+                        rv2 := reflect.New(rv.Type())
+                        rv2.Elem().Set(rv)
+                        v = rv2.Interface()
+                }
+        }
+        return v
+}
diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
index 75565cc..fdd328b 100644
--- a/vendor/github.com/golang/protobuf/proto/lib.go
+++ b/vendor/github.com/golang/protobuf/proto/lib.go
@@ -341,26 +341,6 @@ type Message interface {
         ProtoMessage()
 }
 
-// Stats records allocation details about the protocol buffer encoders
-// and decoders.  Useful for tuning the library itself.
-type Stats struct {
-        Emalloc uint64 // mallocs in encode
-        Dmalloc uint64 // mallocs in decode
-        Encode  uint64 // number of encodes
-        Decode  uint64 // number of decodes
-        Chit    uint64 // number of cache hits
-        Cmiss   uint64 // number of cache misses
-        Size    uint64 // number of sizes
-}
-
-// Set to true to enable stats collection.
-const collectStats = false
-
-var stats Stats
-
-// GetStats returns a copy of the global Stats structure.
-func GetStats() Stats { return stats }
-
 // A Buffer is a buffer manager for marshaling and unmarshaling
 // protocol buffers.  It may be reused between invocations to
 // reduce memory usage.  It is not necessary to use a Buffer;
@@ -960,13 +940,19 @@ func isProto3Zero(v reflect.Value) bool {
         return false
 }
 
-// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the proto package.
-const ProtoPackageIsVersion2 = true
+const (
+        // ProtoPackageIsVersion3 is referenced from generated protocol buffer files
+        // to assert that that code is compatible with this version of the proto package.
+        ProtoPackageIsVersion3 = true
+
+        // ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+        // to assert that that code is compatible with this version of the proto package.
+        ProtoPackageIsVersion2 = true
 
-// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the proto package.
-const ProtoPackageIsVersion1 = true
+        // ProtoPackageIsVersion1 is referenced from generated protocol buffer files
+        // to assert that that code is compatible with this version of the proto package.
+        ProtoPackageIsVersion1 = true
+)
 
 // InternalMessageInfo is a type used internally by generated .pb.go files.
 // This type is not intended to be used by non-generated code.
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
index 3b6ca41..f48a756 100644
--- a/vendor/github.com/golang/protobuf/proto/message_set.go
+++ b/vendor/github.com/golang/protobuf/proto/message_set.go
@@ -36,13 +36,7 @@ package proto
  */
 
 import (
-        "bytes"
-        "encoding/json"
         "errors"
-        "fmt"
-        "reflect"
-        "sort"
-        "sync"
 )
 
 // errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
@@ -145,46 +139,9 @@ func skipVarint(buf []byte) []byte {
         return buf[i+1:]
 }
 
-// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
-// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSet(exts interface{}) ([]byte, error) {
-        return marshalMessageSet(exts, false)
-}
-
-// marshaMessageSet implements above function, with the opt to turn on / off deterministic during Marshal.
-func marshalMessageSet(exts interface{}, deterministic bool) ([]byte, error) {
-        switch exts := exts.(type) {
-        case *XXX_InternalExtensions:
-                var u marshalInfo
-                siz := u.sizeMessageSet(exts)
-                b := make([]byte, 0, siz)
-                return u.appendMessageSet(b, exts, deterministic)
-
-        case map[int32]Extension:
-                // This is an old-style extension map.
-                // Wrap it in a new-style XXX_InternalExtensions.
-                ie := XXX_InternalExtensions{
-                        p: &struct {
-                                mu           sync.Mutex
-                                extensionMap map[int32]Extension
-                        }{
-                                extensionMap: exts,
-                        },
-                }
-
-                var u marshalInfo
-                siz := u.sizeMessageSet(&ie)
-                b := make([]byte, 0, siz)
-                return u.appendMessageSet(b, &ie, deterministic)
-
-        default:
-                return nil, errors.New("proto: not an extension map")
-        }
-}
-
-// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
 // It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSet(buf []byte, exts interface{}) error {
+func unmarshalMessageSet(buf []byte, exts interface{}) error {
         var m map[int32]Extension
         switch exts := exts.(type) {
         case *XXX_InternalExtensions:
@@ -222,93 +179,3 @@ func UnmarshalMessageSet(buf []byte, exts interface{}) error {
         }
         return nil
 }
-
-// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
-// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
-        var m map[int32]Extension
-        switch exts := exts.(type) {
-        case *XXX_InternalExtensions:
-                var mu sync.Locker
-                m, mu = exts.extensionsRead()
-                if m != nil {
-                        // Keep the extensions map locked until we're done marshaling to prevent
-                        // races between marshaling and unmarshaling the lazily-{en,de}coded
-                        // values.
-                        mu.Lock()
-                        defer mu.Unlock()
-                }
-        case map[int32]Extension:
-                m = exts
-        default:
-                return nil, errors.New("proto: not an extension map")
-        }
-        var b bytes.Buffer
-        b.WriteByte('{')
-
-        // Process the map in key order for deterministic output.
-        ids := make([]int32, 0, len(m))
-        for id := range m {
-                ids = append(ids, id)
-        }
-        sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
-
-        for i, id := range ids {
-                ext := m[id]
-                msd, ok := messageSetMap[id]
-                if !ok {
-                        // Unknown type; we can't render it, so skip it.
-                        continue
-                }
-
-                if i > 0 && b.Len() > 1 {
-                        b.WriteByte(',')
-                }
-
-                fmt.Fprintf(&b, `"[%s]":`, msd.name)
-
-                x := ext.value
-                if x == nil {
-                        x = reflect.New(msd.t.Elem()).Interface()
-                        if err := Unmarshal(ext.enc, x.(Message)); err != nil {
-                                return nil, err
-                        }
-                }
-                d, err := json.Marshal(x)
-                if err != nil {
-                        return nil, err
-                }
-                b.Write(d)
-        }
-        b.WriteByte('}')
-        return b.Bytes(), nil
-}
-
-// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
-// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
-        // Common-case fast path.
-        if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
-                return nil
-        }
-
-        // This is fairly tricky, and it's not clear that it is needed.
-        return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
-}
-
-// A global registry of types that can be used in a MessageSet.
-
-var messageSetMap = make(map[int32]messageSetDesc)
-
-type messageSetDesc struct {
-        t    reflect.Type // pointer to struct
-        name string
-}
-
-// RegisterMessageSetType is called from the generated code.
-func RegisterMessageSetType(m Message, fieldNum int32, name string) {
-        messageSetMap[fieldNum] = messageSetDesc{
-                t:    reflect.TypeOf(m),
-                name: name,
-        }
-}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
index b6cad90..94fa919 100644
--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
@@ -79,10 +79,13 @@ func toPointer(i *Message) pointer {
 
 // toAddrPointer converts an interface to a pointer that points to
 // the interface data.
-func toAddrPointer(i *interface{}, isptr bool) pointer {
+func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
         v := reflect.ValueOf(*i)
         u := reflect.New(v.Type())
         u.Elem().Set(v)
+        if deref {
+                u = u.Elem()
+        }
         return pointer{v: u}
 }
 
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
index d55a335..dbfffe0 100644
--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
@@ -85,16 +85,21 @@ func toPointer(i *Message) pointer {
 
 // toAddrPointer converts an interface to a pointer that points to
 // the interface data.
-func toAddrPointer(i *interface{}, isptr bool) pointer {
+func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
         // Super-tricky - read or get the address of data word of interface value.
         if isptr {
                 // The interface is of pointer type, thus it is a direct interface.
                 // The data word is the pointer data itself. We take its address.
-                return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
+                p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
+        } else {
+                // The interface is not of pointer type. The data word is the pointer
+                // to the data.
+                p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
         }
-        // The interface is not of pointer type. The data word is the pointer
-        // to the data.
-        return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+        if deref {
+                p.p = *(*unsafe.Pointer)(p.p)
+        }
+        return p
 }
 
 // valToPointer converts v to a pointer. v must be of pointer type.
diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
index 50b99b8..79668ff 100644
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -334,9 +334,6 @@ func GetProperties(t reflect.Type) *StructProperties {
         sprop, ok := propertiesMap[t]
         propertiesMu.RUnlock()
         if ok {
-                if collectStats {
-                        stats.Chit++
-                }
                 return sprop
         }
 
@@ -346,17 +343,20 @@ func GetProperties(t reflect.Type) *StructProperties {
         return sprop
 }
 
+type (
+        oneofFuncsIface interface {
+                XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+        }
+        oneofWrappersIface interface {
+                XXX_OneofWrappers() []interface{}
+        }
+)
+
 // getPropertiesLocked requires that propertiesMu is held.
 func getPropertiesLocked(t reflect.Type) *StructProperties {
         if prop, ok := propertiesMap[t]; ok {
-                if collectStats {
-                        stats.Chit++
-                }
                 return prop
         }
-        if collectStats {
-                stats.Cmiss++
-        }
 
         prop := new(StructProperties)
         // in case of recursive protos, fill this in now.
@@ -391,13 +391,14 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {
         // Re-order prop.order.
         sort.Sort(prop)
 
-        type oneofMessage interface {
-                XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+        var oots []interface{}
+        switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+        case oneofFuncsIface:
+                _, _, _, oots = m.XXX_OneofFuncs()
+        case oneofWrappersIface:
+                oots = m.XXX_OneofWrappers()
         }
-        if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
-                var oots []interface{}
-                _, _, _, oots = om.XXX_OneofFuncs()
-
+        if len(oots) > 0 {
                 // Interpret oneof metadata.
                 prop.OneofTypes = make(map[string]*OneofProperties)
                 for _, oot := range oots {
diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.go
index b167944..5cb11fa 100644
--- a/vendor/github.com/golang/protobuf/proto/table_marshal.go
+++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go
@@ -87,6 +87,7 @@ type marshalElemInfo struct {
         sizer     sizer
         marshaler marshaler
         isptr     bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
+        deref     bool // dereference the pointer before operating on it; implies isptr
 }
 
 var (
@@ -320,8 +321,11 @@ func (u *marshalInfo) computeMarshalInfo() {
 
         // get oneof implementers
         var oneofImplementers []interface{}
-        if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
+        switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+        case oneofFuncsIface:
                 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
+        case oneofWrappersIface:
+                oneofImplementers = m.XXX_OneofWrappers()
         }
 
         n := t.NumField()
@@ -407,13 +411,22 @@ func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
                 panic("tag is not an integer")
         }
         wt := wiretype(tags[0])
+        if t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct {
+                t = t.Elem()
+        }
         sizer, marshaler := typeMarshaler(t, tags, false, false)
+        var deref bool
+        if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+                t = reflect.PtrTo(t)
+                deref = true
+        }
         e = &marshalElemInfo{
                 wiretag:   uint64(tag)<<3 | wt,
                 tagsize:   SizeVarint(uint64(tag) << 3),
                 sizer:     sizer,
                 marshaler: marshaler,
                 isptr:     t.Kind() == reflect.Ptr,
+                deref:     deref,
         }
 
         // update cache
@@ -448,7 +461,7 @@ func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
 
 func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
         fi.field = toField(f)
-        fi.wiretag = 1<<31 - 1 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
+        fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
         fi.isPointer = true
         fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
         fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
@@ -476,10 +489,6 @@ func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofI
         }
 }
 
-type oneofMessage interface {
-        XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
-}
-
 // wiretype returns the wire encoding of the type.
 func wiretype(encoding string) uint64 {
         switch encoding {
@@ -2310,8 +2319,8 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
                         for _, k := range m.MapKeys() {
                                 ki := k.Interface()
                                 vi := m.MapIndex(k).Interface()
-                                kaddr := toAddrPointer(&ki, false)             // pointer to key
-                                vaddr := toAddrPointer(&vi, valIsPtr)          // pointer to value
+                                kaddr := toAddrPointer(&ki, false, false)      // pointer to key
+                                vaddr := toAddrPointer(&vi, valIsPtr, false)   // pointer to value
                                 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
                                 n += siz + SizeVarint(uint64(siz)) + tagsize
                         }
@@ -2329,8 +2338,8 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
                         for _, k := range keys {
                                 ki := k.Interface()
                                 vi := m.MapIndex(k).Interface()
-                                kaddr := toAddrPointer(&ki, false)    // pointer to key
-                                vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
+                                kaddr := toAddrPointer(&ki, false, false)    // pointer to key
+                                vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
                                 b = appendVarint(b, tag)
                                 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
                                 b = appendVarint(b, uint64(siz))
@@ -2399,7 +2408,7 @@ func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
                 // the last time this function was called.
                 ei := u.getExtElemInfo(e.desc)
                 v := e.value
-                p := toAddrPointer(&v, ei.isptr)
+                p := toAddrPointer(&v, ei.isptr, ei.deref)
                 n += ei.sizer(p, ei.tagsize)
         }
         mu.Unlock()
@@ -2434,7 +2443,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de
 
                         ei := u.getExtElemInfo(e.desc)
                         v := e.value
-                        p := toAddrPointer(&v, ei.isptr)
+                        p := toAddrPointer(&v, ei.isptr, ei.deref)
                         b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
                         if !nerr.Merge(err) {
                                 return b, err
@@ -2465,7 +2474,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de
 
                 ei := u.getExtElemInfo(e.desc)
                 v := e.value
-                p := toAddrPointer(&v, ei.isptr)
+                p := toAddrPointer(&v, ei.isptr, ei.deref)
                 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
                 if !nerr.Merge(err) {
                         return b, err
@@ -2510,7 +2519,7 @@ func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
 
                 ei := u.getExtElemInfo(e.desc)
                 v := e.value
-                p := toAddrPointer(&v, ei.isptr)
+                p := toAddrPointer(&v, ei.isptr, ei.deref)
                 n += ei.sizer(p, 1) // message, tag = 3 (size=1)
         }
         mu.Unlock()
@@ -2553,7 +2562,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de
 
                         ei := u.getExtElemInfo(e.desc)
                         v := e.value
-                        p := toAddrPointer(&v, ei.isptr)
+                        p := toAddrPointer(&v, ei.isptr, ei.deref)
                         b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
                         if !nerr.Merge(err) {
                                 return b, err
@@ -2591,7 +2600,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de
 
                 ei := u.getExtElemInfo(e.desc)
                 v := e.value
-                p := toAddrPointer(&v, ei.isptr)
+                p := toAddrPointer(&v, ei.isptr, ei.deref)
                 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
                 b = append(b, 1<<3|WireEndGroup)
                 if !nerr.Merge(err) {
@@ -2621,7 +2630,7 @@ func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
 
                 ei := u.getExtElemInfo(e.desc)
                 v := e.value
-                p := toAddrPointer(&v, ei.isptr)
+                p := toAddrPointer(&v, ei.isptr, ei.deref)
                 n += ei.sizer(p, ei.tagsize)
         }
         return n
@@ -2656,7 +2665,7 @@ func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, determ
 
                 ei := u.getExtElemInfo(e.desc)
                 v := e.value
-                p := toAddrPointer(&v, ei.isptr)
+                p := toAddrPointer(&v, ei.isptr, ei.deref)
                 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
                 if !nerr.Merge(err) {
                         return b, err
diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
index ebf1caa..acee2fc 100644
--- a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
+++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
@@ -136,7 +136,7 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
                 u.computeUnmarshalInfo()
         }
         if u.isMessageSet {
-                return UnmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
+                return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
         }
         var reqMask uint64 // bitmask of required fields we've seen.
         var errLater error
@@ -362,46 +362,48 @@ func (u *unmarshalInfo) computeUnmarshalInfo() {
         }
 
         // Find any types associated with oneof fields.
-        // TODO: XXX_OneofFuncs returns more info than we need.  Get rid of some of it?
-        fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs")
-        if fn.IsValid() {
-                res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{}
-                for i := res.Len() - 1; i >= 0; i-- {
-                        v := res.Index(i)                             // interface{}
-                        tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X
-                        typ := tptr.Elem()                            // Msg_X
-
-                        f := typ.Field(0) // oneof implementers have one field
-                        baseUnmarshal := fieldUnmarshaler(&f)
-                        tags := strings.Split(f.Tag.Get("protobuf"), ",")
-                        fieldNum, err := strconv.Atoi(tags[1])
-                        if err != nil {
-                                panic("protobuf tag field not an integer: " + tags[1])
-                        }
-                        var name string
-                        for _, tag := range tags {
-                                if strings.HasPrefix(tag, "name=") {
-                                        name = strings.TrimPrefix(tag, "name=")
-                                        break
-                                }
+        var oneofImplementers []interface{}
+        switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+        case oneofFuncsIface:
+                _, _, _, oneofImplementers = m.XXX_OneofFuncs()
+        case oneofWrappersIface:
+                oneofImplementers = m.XXX_OneofWrappers()
+        }
+        for _, v := range oneofImplementers {
+                tptr := reflect.TypeOf(v) // *Msg_X
+                typ := tptr.Elem()        // Msg_X
+
+                f := typ.Field(0) // oneof implementers have one field
+                baseUnmarshal := fieldUnmarshaler(&f)
+                tags := strings.Split(f.Tag.Get("protobuf"), ",")
+                fieldNum, err := strconv.Atoi(tags[1])
+                if err != nil {
+                        panic("protobuf tag field not an integer: " + tags[1])
+                }
+                var name string
+                for _, tag := range tags {
+                        if strings.HasPrefix(tag, "name=") {
+                                name = strings.TrimPrefix(tag, "name=")
+                                break
                         }
+                }
 
-                        // Find the oneof field that this struct implements.
-                        // Might take O(n^2) to process all of the oneofs, but who cares.
-                        for _, of := range oneofFields {
-                                if tptr.Implements(of.ityp) {
-                                        // We have found the corresponding interface for this struct.
-                                        // That lets us know where this struct should be stored
-                                        // when we encounter it during unmarshaling.
-                                        unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
-                                        u.setTag(fieldNum, of.field, unmarshal, 0, name)
-                                }
+                // Find the oneof field that this struct implements.
+                // Might take O(n^2) to process all of the oneofs, but who cares.
+                for _, of := range oneofFields {
+                        if tptr.Implements(of.ityp) {
+                                // We have found the corresponding interface for this struct.
+                                // That lets us know where this struct should be stored
+                                // when we encounter it during unmarshaling.
+                                unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
+                                u.setTag(fieldNum, of.field, unmarshal, 0, name)
                         }
                 }
+
         }
 
         // Get extension ranges, if any.
-        fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
+        fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
         if fn.IsValid() {
                 if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
                         panic("a message with extensions, but no extensions field in " + t.Name())
@@ -1948,7 +1950,7 @@ func encodeVarint(b []byte, x uint64) []byte {
 // If there is an error, it returns 0,0.
 func decodeVarint(b []byte) (uint64, int) {
         var x, y uint64
-        if len(b) <= 0 {
+        if len(b) == 0 {
                 goto bad
         }
         x = uint64(b[0])