all: Move remaining protos to use the vanity plugin (#7009)

lib/protocol/protocol.go

@@ -153,12 +153,12 @@ type rawConnection struct {
 	cr *countingReader
 	cw *countingWriter
 
-	awaiting    map[int32]chan asyncResult
+	awaiting    map[int]chan asyncResult
 	awaitingMut sync.Mutex
 
 	idxMut sync.Mutex // ensures serialization of Index calls
 
-	nextID    int32
+	nextID    int
 	nextIDMut sync.Mutex
 
 	inbox                 chan message
@@ -213,7 +213,7 @@ func NewConnection(deviceID DeviceID, reader io.Reader, writer io.Writer, receiv
 		receiver:              nativeModel{receiver},
 		cr:                    cr,
 		cw:                    cw,
-		awaiting:              make(map[int32]chan asyncResult),
+		awaiting:              make(map[int]chan asyncResult),
 		inbox:                 make(chan message),
 		outbox:                make(chan asyncMessage),
 		closeBox:              make(chan asyncMessage),
@@ -301,7 +301,7 @@ func (c *rawConnection) Request(ctx context.Context, folder string, name string,
 		Folder:        folder,
 		Name:          name,
 		Offset:        offset,
-		Size:          int32(size),
+		Size:          size,
 		Hash:          hash,
 		WeakHash:      weakHash,
 		FromTemporary: fromTemporary,
@@ -625,7 +625,7 @@ func checkFilename(name string) error {
 }
 
 func (c *rawConnection) handleRequest(req Request) {
-	res, err := c.receiver.Request(c.id, req.Folder, req.Name, req.Size, req.Offset, req.Hash, req.WeakHash, req.FromTemporary)
+	res, err := c.receiver.Request(c.id, req.Folder, req.Name, int32(req.Size), req.Offset, req.Hash, req.WeakHash, req.FromTemporary)
 	if err != nil {
 		c.send(context.Background(), &Response{
 			ID:   req.ID,
@@ -797,21 +797,21 @@ func (c *rawConnection) writeUncompressedMessage(msg message) error {
 func (c *rawConnection) typeOf(msg message) MessageType {
 	switch msg.(type) {
 	case *ClusterConfig:
-		return messageTypeClusterConfig
+		return MessageTypeClusterConfig
 	case *Index:
-		return messageTypeIndex
+		return MessageTypeIndex
 	case *IndexUpdate:
-		return messageTypeIndexUpdate
+		return MessageTypeIndexUpdate
 	case *Request:
-		return messageTypeRequest
+		return MessageTypeRequest
 	case *Response:
-		return messageTypeResponse
+		return MessageTypeResponse
 	case *DownloadProgress:
-		return messageTypeDownloadProgress
+		return MessageTypeDownloadProgress
 	case *Ping:
-		return messageTypePing
+		return MessageTypePing
 	case *Close:
-		return messageTypeClose
+		return MessageTypeClose
 	default:
 		panic("bug: unknown message type")
 	}
@@ -819,21 +819,21 @@ func (c *rawConnection) typeOf(msg message) MessageType {
 
 func (c *rawConnection) newMessage(t MessageType) (message, error) {
 	switch t {
-	case messageTypeClusterConfig:
+	case MessageTypeClusterConfig:
 		return new(ClusterConfig), nil
-	case messageTypeIndex:
+	case MessageTypeIndex:
 		return new(Index), nil
-	case messageTypeIndexUpdate:
+	case MessageTypeIndexUpdate:
 		return new(IndexUpdate), nil
-	case messageTypeRequest:
+	case MessageTypeRequest:
 		return new(Request), nil
-	case messageTypeResponse:
+	case MessageTypeResponse:
 		return new(Response), nil
-	case messageTypeDownloadProgress:
+	case MessageTypeDownloadProgress:
 		return new(DownloadProgress), nil
-	case messageTypePing:
+	case MessageTypePing:
 		return new(Ping), nil
-	case messageTypeClose:
+	case MessageTypeClose:
 		return new(Close), nil
 	default:
 		return nil, errUnknownMessage
@@ -842,14 +842,14 @@ func (c *rawConnection) newMessage(t MessageType) (message, error) {
 
 func (c *rawConnection) shouldCompressMessage(msg message) bool {
 	switch c.compression {
-	case CompressNever:
+	case CompressionNever:
 		return false
 
-	case CompressAlways:
+	case CompressionAlways:
 		// Use compression for large enough messages
 		return msg.ProtoSize() >= compressionThreshold
 
-	case CompressMetadata:
+	case CompressionMetadata:
 		_, isResponse := msg.(*Response)
 		// Compress if it's large enough and not a response message
 		return !isResponse && msg.ProtoSize() >= compressionThreshold