Update mojo sdk to rev f84766d3b6420b7cf6a113d9d65d73cb5fe18d90

third_party/mojo/src/mojo/public/go/bindings/message.go

 // Copyright 2015 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 bindings
 
 import (
         "fmt"
 
         "mojo/public/go/system"
@@ skipping 10 matching lines @@
         MessageIsResponseFlag = 1 << 1
 
         dataHeaderSize   = 8
         defaultAlignment = 8
         pointerBitSize   = 64
 )
 
 var mapHeader DataHeader
 
 func init() {
-        mapHeader = DataHeader{24, 2}
+        mapHeader = DataHeader{24, 0}
 }
 
 const (
         DifferentSizedArraysInMap     = "VALIDATION_ERROR_DIFFERENT_SIZED_ARRAYS_IN_MAP"
         IllegalHandle                 = "VALIDATION_ERROR_ILLEGAL_HANDLE"
         IllegalMemoryRange            = "VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE"
         IllegalPointer                = "VALIDATION_ERROR_ILLEGAL_POINTER"
         MessageHeaderInvalidFlags     = "VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAGS"
         MessageHeaderMissingRequestId = "VALIDATION_ERROR_MESSAGE_HEADER_MISSING_REQUEST_ID"
         MessageHeaderUnknownMethod    = "VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD"
@@ skipping 28 matching lines @@
 }
 
 // MessageHeader is a header information for a message.
 type MessageHeader struct {
         Type      uint32
         Flags     uint32
         RequestId uint64
 }
 
 func (h *MessageHeader) Encode(encoder *Encoder) error {
-        encoder.StartStruct(h.dataSize(), h.numFields())
+        encoder.StartStruct(h.dataSize(), h.version())
         if err := encoder.WriteUint32(h.Type); err != nil {
                 return err
         }
         if err := encoder.WriteUint32(h.Flags); err != nil {
                 return err
         }
         if h.RequestId != 0 {
                 if err := encoder.WriteUint64(h.RequestId); err != nil {
                         return err
                 }
         }
         return encoder.Finish()
 }
 
 func (h *MessageHeader) Decode(decoder *Decoder) error {
         header, err := decoder.StartStruct()
         if err != nil {
                 return err
         }
-        numFields := header.ElementsOrVersion
-        if numFields < 2 || numFields > 3 {
+        version := header.ElementsOrVersion
+        if version > 1 {
                 return &ValidationError{UnexpectedStructHeader,
-                        fmt.Sprintf("invalid message header: it should have 2 or 3 fileds, but has %d", numFields),
+                        fmt.Sprintf("invalid message header: it should be of version 0 or 1, but has %d", version),
                 }
         }
         expectedSize := uint32(dataHeaderSize + 2*4)
-        if numFields == 3 {
+        if version == 1 {
                 expectedSize += 8
         }
         if expectedSize != header.Size {
                 return &ValidationError{UnexpectedStructHeader,
                         fmt.Sprintf("unexpected struct header size: expected %d, but got %d", expectedSize, header.Size),
                 }
         }
 
         if h.Type, err = decoder.ReadUint32(); err != nil {
                 return err
         }
         if h.Flags, err = decoder.ReadUint32(); err != nil {
                 return err
         }
-        if numFields == 3 {
+        if version == 1 {
                 if h.Flags != MessageExpectsResponseFlag && h.Flags != MessageIsResponseFlag {
                         return &ValidationError{MessageHeaderInvalidFlags,
                                 fmt.Sprintf("message header flags(%v) should be MessageExpectsResponseFlag or MessageIsResponseFlag", h.Flags),
                         }
                 }
                 if h.RequestId, err = decoder.ReadUint64(); err != nil {
                         return err
                 }
         } else {
                 if h.Flags != MessageNoFlag {
                         return &ValidationError{MessageHeaderMissingRequestId, "missing request ID in message header"}
                 }
         }
         return decoder.Finish()
 }
 
 func (h *MessageHeader) dataSize() uint32 {
         var size uint32
         size = 2 * 4
         if h.RequestId != 0 {
                 size += 8
         }
         return size
 }
 
-func (h *MessageHeader) numFields() uint32 {
+func (h *MessageHeader) version() uint32 {
         if h.RequestId != 0 {
-                return 3
+                return 1
         } else {
-                return 2
+                return 0
         }
 }
 
 // Message is a a raw message to be sent/received from a message pipe handle
 // which contains a message header.
 type Message struct {
         Header  MessageHeader
         Bytes   []byte
         Handles []system.UntypedHandle
         Payload []byte
@@ skipping 32 matching lines @@
 // ParseMessage parses message header from byte buffer with attached handles
 // and returnes parsed message.
 func ParseMessage(bytes []byte, handles []system.UntypedHandle) (*Message, error) {
         decoder := NewDecoder(bytes, []system.UntypedHandle{})
         var header MessageHeader
         if err := header.Decode(decoder); err != nil {
                 return nil, err
         }
         return newMessage(header, bytes, handles), nil
 }