Revert "Update mojo sdk to rev 8d45c89c30b230843c5bd6dd0693a555750946c0"

third_party/mojo/src/mojo/public/go/bindings/decoder.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 (
         "encoding/binary"
         "fmt"
         "math"
@@ skipping 167 matching lines @@
 func (d *Decoder) ReadInt8() (int8, error) {
         value, err := d.ReadUint8()
         return int8(value), err
 }
 
 // ReadUint8 reads an uint8 value.
 func (d *Decoder) ReadUint8() (uint8, error) {
         if err := ensureElementBitSizeAndCapacity(d.state(), 8); err != nil {
                 return 0, err
         }
-        d.state().alignOffsetToBytes()
         value := d.buf[d.state().offset]
         d.state().skipBytes(1)
         d.state().elementsProcessed++
         return value, nil
 }
 
 // ReadInt16 reads an int16 value.
 func (d *Decoder) ReadInt16() (int16, error) {
         value, err := d.ReadUint16()
         return int16(value), err
 }
 
 // ReadUint16 reads an uint16 value.
 func (d *Decoder) ReadUint16() (uint16, error) {
         if err := ensureElementBitSizeAndCapacity(d.state(), 16); err != nil {
                 return 0, err
         }
-        d.state().alignOffsetToBytes()
         d.state().offset = align(d.state().offset, 2)
         value := binary.LittleEndian.Uint16(d.buf[d.state().offset:])
         d.state().skipBytes(2)
         d.state().elementsProcessed++
         return value, nil
 }
 
 // ReadInt32 reads an int32 value.
 func (d *Decoder) ReadInt32() (int32, error) {
         value, err := d.ReadUint32()
         return int32(value), err
 }
 
 // ReadUint32 reads an uint32 value.
 func (d *Decoder) ReadUint32() (uint32, error) {
         if err := ensureElementBitSizeAndCapacity(d.state(), 32); err != nil {
                 return 0, err
         }
-        d.state().alignOffsetToBytes()
         d.state().offset = align(d.state().offset, 4)
         value := binary.LittleEndian.Uint32(d.buf[d.state().offset:])
         d.state().skipBytes(4)
         d.state().elementsProcessed++
         return value, nil
 }
 
 // ReadInt64 reads an int64 value.
 func (d *Decoder) ReadInt64() (int64, error) {
         value, err := d.ReadUint64()
         return int64(value), err
 }
 
 // ReadUint64 reads an uint64 value.
 func (d *Decoder) ReadUint64() (uint64, error) {
         if err := ensureElementBitSizeAndCapacity(d.state(), 64); err != nil {
                 return 0, err
         }
-        d.state().alignOffsetToBytes()
         d.state().offset = align(d.state().offset, 8)
         value := binary.LittleEndian.Uint64(d.buf[d.state().offset:])
         d.state().skipBytes(8)
         d.state().elementsProcessed++
         return value, nil
 }
 
 // ReadFloat32 reads a float32 value.
 func (d *Decoder) ReadFloat32() (float32, error) {
         bits, err := d.ReadUint32()
@@ skipping 42 matching lines @@
         newEnd := uint64(oldEnd) + pointer
         if newEnd >= uint64(len(d.buf)) {
                 return 0, fmt.Errorf("trying to access out of range memory")
         }
         if newEnd < uint64(d.end) {
                 return 0, fmt.Errorf("trying to access memory out of order")
         }
         if newEnd%8 != 0 {
                 return 0, fmt.Errorf("incorrect pointer data alignment: %d", newEnd)
         }
-        d.claimData(int(newEnd) - d.end)
+        d.claimData(d.end - int(newEnd))
         return pointer, nil
 }
 
-// ReadUntypedHandle reads an untyped handle.
-func (d *Decoder) ReadUntypedHandle() (system.UntypedHandle, error) {
+// ReadMessagePipeHandle reads a message pipe handle.
+func (d *Decoder) ReadMessagePipeHandle() (system.MessagePipeHandle, error) {
         handleIndex, err := d.ReadUint32()
         if err != nil {
                 return nil, err
         }
-        if handleIndex == ^uint32(0) {
-                return &InvalidHandle{}, nil
-        }
-        return d.claimHandle(int(handleIndex))
+        untypedHandle, err := d.claimHandle(int(handleIndex))
+        return untypedHandle.ToMessagePipeHandle(), err
 }
-
-// ReadHandle reads a handle.
-func (d *Decoder) ReadHandle() (system.Handle, error) {
-        return d.ReadUntypedHandle()
-}
-
-// ReadMessagePipeHandle reads a message pipe handle.
-func (d *Decoder) ReadMessagePipeHandle() (system.MessagePipeHandle, error) {
-        if handle, err := d.ReadUntypedHandle(); err != nil {
-                return nil, err
-        } else {
-                return handle.ToMessagePipeHandle(), nil
-        }
-}
-
-// ReadConsumerHandle reads a data pipe consumer handle.
-func (d *Decoder) ReadConsumerHandle() (system.ConsumerHandle, error) {
-        if handle, err := d.ReadUntypedHandle(); err != nil {
-                return nil, err
-        } else {
-                return handle.ToConsumerHandle(), nil
-        }
-}
-
-// ReadProducerHandle reads a data pipe producer handle.
-func (d *Decoder) ReadProducerHandle() (system.ProducerHandle, error) {
-        if handle, err := d.ReadUntypedHandle(); err != nil {
-                return nil, err
-        } else {
-                return handle.ToProducerHandle(), nil
-        }
-}
-
-// ReadSharedBufferHandle reads a shared buffer handle.
-func (d *Decoder) ReadSharedBufferHandle() (system.SharedBufferHandle, error) {
-        if handle, err := d.ReadUntypedHandle(); err != nil {
-                return nil, err
-        } else {
-                return handle.ToSharedBufferHandle(), nil
-        }
-}