Update the protocol buffer library to use Int64 from the fixnum package

lib/coded_buffer_writer.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of protobuf;
 
 class CodedBufferWriter {
 
   final List<TypedData> _output = <TypedData>[];
   int _runningSizeInBytes = 0;
 
   static final _WRITE_FUNCTION_MAP = _makeWriteFunctionMap();
 
   static ByteData _toVarint32(int value) {
     // Varint encoding always fits into 5 bytes.
     Uint8List result = new Uint8List(5);
     int i = 0;
     while (value >= 0x80) {
       result[i++] = 0x80 | (value & 0x7f);
       value >>= 7;
     }
     result[i++] = value;
 
     return new ByteData.view(result.buffer, 0, i);
   }
 
-  static ByteData _toVarint64(ByteData value) {
+  static ByteData _toVarint64(Int64 value) {
     // Varint encoding always fits into 10 bytes.
     Uint8List result = new Uint8List(10);
     int i = 0;
-    int lo = value.getUint32(0, Endianness.LITTLE_ENDIAN);
-    int hi = value.getUint32(4, Endianness.LITTLE_ENDIAN);
+    ByteData bytes =
+        new ByteData.view(new Uint8List.fromList(value.toBytes()).buffer, 0, 8);
+    int lo = bytes.getUint32(0, Endianness.LITTLE_ENDIAN);
+    int hi = bytes.getUint32(4, Endianness.LITTLE_ENDIAN);
     while (hi > 0 || lo >= 0x80) {
       result[i++] = 0x80 | (lo & 0x7f);
       lo = (lo >> 7) | ((hi & 0x7f) << 25);
       hi >>= 7;
     }
     result[i++] = lo;
 
     return new ByteData.view(result.buffer, 0, i);
   }
 
   static ByteData _int32ToBytes(int value) => _toVarint32(value & 0xffffffff);
 
   static _makeWriteFunctionMap() {
     writeBytesNoTag(output, List<int> value) {
       output.writeInt32NoTag(value.length);
       output.writeRawBytes(
           new Uint8List(value.length)..setRange(0, value.length, value));
     }
 
     makeWriter(convertor) => ((output, value) {
       output.writeRawBytes(convertor(value));
     });
 
     int _encodeZigZag32(int value) => (value << 1) ^ (value >> 31);
 
-    ByteData _encodeZigZag64(ByteData value) {
-      int lo = value.getUint32(0, Endianness.LITTLE_ENDIAN);
-      int hi = value.getUint32(4, Endianness.LITTLE_ENDIAN);
-      int newHi = (hi << 1) | (lo >> 31);
-      int newLo = (lo << 1);
-      if ((hi >> 31) == 1) {
-        newHi ^= 0xffffffff;
-        newLo ^= 0xffffffff;
-      }
-      return new ByteData(8)
-          ..setUint32(0, newLo, Endianness.LITTLE_ENDIAN)
-          ..setUint32(4, newHi, Endianness.LITTLE_ENDIAN);
+    Int64 _encodeZigZag64(Int64 value) => (value << 1) ^ (value >> 63);
+
+    ByteData makeByteData32(int value) =>
+        new ByteData(4)..setUint32(0, value, Endianness.LITTLE_ENDIAN);
+
+    ByteData makeByteData64(Int64 value) {
+      var data = new Uint8List.fromList(value.toBytes());
+      return new ByteData.view(data.buffer, 0, 8);
     }
 
-
-    makeByteData32(int value) =>
-        new ByteData(4)..setUint32(0, value, Endianness.LITTLE_ENDIAN);
-
     return new Map<int, dynamic>()
         ..[GeneratedMessage._BOOL_BIT] = makeWriter(
             (value) => _int32ToBytes(value ? 1 : 0))
         ..[GeneratedMessage._BYTES_BIT] = writeBytesNoTag
         ..[GeneratedMessage._STRING_BIT] = (output, value) {
             writeBytesNoTag(output, encodeUtf8(value));
         }
         ..[GeneratedMessage._DOUBLE_BIT] = makeWriter((double value) {
             if (value.isNaN) return new ByteData(8)
                   ..setUint32(0, 0x00000000, Endianness.LITTLE_ENDIAN)
@@ skipping 20 matching lines @@
             (value) => _int32ToBytes(value.value))
         ..[GeneratedMessage._GROUP_BIT] = (output, value) {
             value.writeToCodedBufferWriter(output);
         }
         ..[GeneratedMessage._INT32_BIT] = makeWriter(_int32ToBytes)
         ..[GeneratedMessage._INT64_BIT] = makeWriter(
             (value) => _toVarint64(value))
         ..[GeneratedMessage._SINT32_BIT] = makeWriter(
             (int value) => _int32ToBytes(_encodeZigZag32(value)))
         ..[GeneratedMessage._SINT64_BIT] = makeWriter(
-            (ByteData value) => _toVarint64(_encodeZigZag64(value)))
+            (Int64 value) => _toVarint64(_encodeZigZag64(value)))
         ..[GeneratedMessage._UINT32_BIT] = makeWriter(_toVarint32)
         ..[GeneratedMessage._UINT64_BIT] = makeWriter(_toVarint64)
         ..[GeneratedMessage._FIXED32_BIT] = makeWriter(makeByteData32)
-        ..[GeneratedMessage._FIXED64_BIT] = makeWriter((x) => x)
+        ..[GeneratedMessage._FIXED64_BIT] = makeWriter(makeByteData64)
         ..[GeneratedMessage._SFIXED32_BIT] = makeWriter(makeByteData32)
-        ..[GeneratedMessage._SFIXED64_BIT] = makeWriter((x) => x)
+        ..[GeneratedMessage._SFIXED64_BIT] = makeWriter(makeByteData64)
         ..[GeneratedMessage._MESSAGE_BIT] = (output, value) {
             output._withDeferredSizeCalculation(() {
               value.writeToCodedBufferWriter(output);
             });
         };
   }
 
   static final _OPEN_TAG_MAP = _makeOpenTagMap();
 
   static _makeOpenTagMap() {
@@ skipping 80 matching lines @@
     int position = 0;
     for (var typedData in _output) {
       Uint8List asBytes = new Uint8List.view(
           typedData.buffer, typedData.offsetInBytes, typedData.lengthInBytes);
       result.setRange(position, position + typedData.lengthInBytes, asBytes);
       position += typedData.lengthInBytes;
     }
     return result;
   }
 }