Send size to NativeViewportClient::OnCreated instead of GLES2Client::DidCreateContext

mojo/apps/js/bindings/codec.js

 // Copyright 2013 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.
 
 define(function() {
 
   // Memory -------------------------------------------------------------------
 
   function store8(memory, pointer, val) {
     memory[pointer] = val;
@@ skipping 77 matching lines @@
   // Decoder ------------------------------------------------------------------
 
   function Decoder(memory, handles, base) {
     this.memory = memory;
     this.handles = handles;
     this.base = base;
     this.next = base;
     this.viewU32 = new Uint32Array(
         this.memory.buffer, 0,
         Math.floor(this.memory.length / Uint32Array.BYTES_PER_ELEMENT));
+    this.viewFloat = new Float32Array(
+        this.memory.buffer, 0,
+        Math.floor(this.memory.length / Float32Array.BYTES_PER_ELEMENT));
   }
 
   Decoder.prototype.skip = function(offset) {
     this.next += offset;
   };
 
   Decoder.prototype.read8 = function() {
     var result = load8(this.memory, this.next);
     this.next += 1;
     return result;
   };
 
   Decoder.prototype.read32 = function() {
     var result = this.viewU32[this.next / this.viewU32.BYTES_PER_ELEMENT];
     this.next += this.viewU32.BYTES_PER_ELEMENT;
     return result;
   };
 
   Decoder.prototype.read64 = function() {
     var low = this.read32();
     var high = this.read32();
     return low + high * 0x100000000;
   };
 
+  Decoder.prototype.decodeFloat = function() {
+    var result = this.viewFloat[this.next / this.viewFloat.BYTES_PER_ELEMENT];
+    this.next += this.viewFloat.BYTES_PER_ELEMENT;
+    return result;
+  };
+
   Decoder.prototype.decodePointer = function() {
     // TODO(abarth): To correctly decode a pointer, we need to know the real
     // base address of the array buffer.
     var offsetPointer = this.next;
     var offset = this.read64();
     if (!offset)
       return 0;
     return offsetPointer + offset;
   };
 
@@ skipping 64 matching lines @@
   Encoder.prototype.write32 = function(val) {
     store32(this.buffer.memory, this.next, val);
     this.next += 4;
   };
 
   Encoder.prototype.write64 = function(val) {
     store64(this.buffer.memory, this.next, val);
     this.next += 8;
   };
 
+  Encoder.prototype.encodeFloat = function(val) {
+    var floatBuffer = new Float32Array(1);
+    floatBuffer[0] = val;
+    var buffer = new Uint8Array(floatBuffer.buffer, 0);
+    for (var i = 0; i < buffer.length; ++i)
+      this.buffer.memory[this.next++] = buffer[i];
+  };
+
   Encoder.prototype.encodePointer = function(pointer) {
     if (!pointer)
       return this.write64(0);
     // TODO(abarth): To correctly encode a pointer, we need to know the real
     // base address of the array buffer.
     var offset = pointer - this.next;
     this.write64(offset);
   };
 
   Encoder.prototype.createAndEncodeEncoder = function(size) {
@@ skipping 217 matching lines @@
   exports.kMessageHeaderSize = kMessageHeaderSize;
   exports.Uint8 = Uint8;
   exports.Uint16 = Uint16;
   exports.Uint32 = Uint32;
   exports.Uint64 = Uint64;
   exports.PointerTo = PointerTo;
   exports.ArrayOf = ArrayOf;
   exports.Handle = Handle;
   return exports;
 });