server/prpc: updated server according to protocol

server/prpc/decoding.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package prpc
 
 import (
         "bytes"
         "encoding/base64"
         "fmt"
@@ skipping 33 matching lines @@
         }
         f, err := parseFormat(mediaType, mediaTypeParams)
         if err != nil {
                 return f, err
         }
 
         switch f {
         case formatUnrecognized:
                 return f, fmt.Errorf("%q is not supported", contentType)
 
-        case formatUnspecified:
-                return formatBinary, nil
-
         case formatBinary, formatJSONPB, formatText:
                 return f, nil
 
         default:
-                panic("cannot happen")
+                return formatBinary, nil
         }
 }
 
 // readMessage decodes a protobuf message from an HTTP request.
 // Does not close the request body.
-func readMessage(r *http.Request, msg proto.Message) *httpError {
-        if msg == nil {
-                panicf("cannot decode to nil")
-        }
+func readMessage(r *http.Request, msg proto.Message) *protocolError {
         format, err := requestFormat(r.Header.Get(headerContentType))
         if err != nil {
                 // Spec: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.16
                 return errorf(http.StatusUnsupportedMediaType, "Content-Type header: %s", err)
         }
 
         buf, err := ioutil.ReadAll(r.Body)
         if err != nil {
                 return errorf(http.StatusBadRequest, "could not read body: %s", err)
         }
-        if len(buf) == 0 {
-                // no body, no message
-                return nil
-        }
-
         switch format {
         // Do not redefine "err" below.
 
         case formatBinary:
                 err = proto.Unmarshal(buf, msg)
 
         case formatJSONPB:
                 err = jsonpb.Unmarshal(bytes.NewBuffer(buf), msg)
 
         case formatText:
                 err = proto.UnmarshalText(string(buf), msg)
 
         default:
-                panicf("cannot happen")
+                err = fmt.Errorf("unknown message format: %d", format)
         }
         if err != nil {
                 return errorf(http.StatusBadRequest, "could not decode body: %s", err)
         }
         return nil
 }
 
 // parseHeader parses HTTP headers and derives a new context.
 // Supports headerTimeout.
 // Ignores "Accept" and "Content-Type" headers.
@@ skipping 47 matching lines @@
                                 }
                                 md[trimmedName] = append(md[trimmedName], string(decoded))
                         }
                 }
         }
         if addedMeta {
                 c = metadata.NewContext(c, md)
         }
         return c, nil
 }