[mojo] Add shared buffer support to mojo JavaScript bindings.

mojo/public/js/core_unittests.js

 // Copyright 2014 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([
     "gin/test/expect",
     "mojo/public/js/core",
     "gc",
   ], function(expect, core, gc) {
 
   var HANDLE_SIGNAL_READWRITABLE = core.HANDLE_SIGNAL_WRITABLE |
                                    core.HANDLE_SIGNAL_READABLE;
   var HANDLE_SIGNAL_ALL = core.HANDLE_SIGNAL_WRITABLE |
                           core.HANDLE_SIGNAL_READABLE |
                           core.HANDLE_SIGNAL_PEER_CLOSED;
 
   runWithMessagePipe(testNop);
   runWithMessagePipe(testReadAndWriteMessage);
   runWithMessagePipeWithOptions(testNop);
   runWithMessagePipeWithOptions(testReadAndWriteMessage);
   runWithDataPipe(testNop);
   runWithDataPipe(testReadAndWriteDataPipe);
   runWithDataPipeWithOptions(testNop);
   runWithDataPipeWithOptions(testReadAndWriteDataPipe);
   runWithMessagePipe(testIsHandleMessagePipe);
   runWithDataPipe(testIsHandleDataPipe);
+  runWithSharedBuffer(testSharedBuffer);
   gc.collectGarbage();  // should not crash
   this.result = "PASS";
 
   function runWithMessagePipe(test) {
     var pipe = core.createMessagePipe();
     expect(pipe.result).toBe(core.RESULT_OK);
 
     test(pipe);
 
     expect(core.close(pipe.handle0)).toBe(core.RESULT_OK);
@@ skipping 29 matching lines @@
         capacityNumBytes: 64
         });
     expect(pipe.result).toBe(core.RESULT_OK);
 
     test(pipe);
 
     expect(core.close(pipe.producerHandle)).toBe(core.RESULT_OK);
     expect(core.close(pipe.consumerHandle)).toBe(core.RESULT_OK);
   }
 
+  function runWithSharedBuffer(test) {
+    let buffer_size = 32;
+    let sharedBuffer = core.createSharedBuffer(buffer_size,
+        core.CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE);
+
+    expect(sharedBuffer.result).toBe(core.RESULT_OK);
+    expect(core.isHandle(sharedBuffer.handle)).toBeTruthy();
+
+    test(sharedBuffer, buffer_size);
+  }
+
   function testNop(pipe) {
   }
 
   function testReadAndWriteMessage(pipe) {
     var wait = core.waitMany([], [], 0);
     expect(wait.result).toBe(core.RESULT_INVALID_ARGUMENT);
     expect(wait.index).toBe(null);
     expect(wait.signalsState).toBe(null);
 
     wait = core.wait(pipe.handle0, core.HANDLE_SIGNAL_READABLE, 0);
@@ skipping 102 matching lines @@
     expect(core.isHandle(pipe.handle0)).toBeTruthy();
     expect(core.isHandle(pipe.handle1)).toBeTruthy();
     expect(core.isHandle(null)).toBeTruthy();
   }
 
   function testIsHandleDataPipe(pipe) {
     expect(core.isHandle(pipe.consumerHandle)).toBeTruthy();
     expect(core.isHandle(pipe.producerHandle)).toBeTruthy();
   }
 
+  function testSharedBuffer(sharedBuffer, buffer_size) {
+    let offset = 0;
+    let mappedBuffer0 = core.mapBuffer(sharedBuffer.handle,
+                                       offset,
+                                       buffer_size,
+                                       core.MAP_BUFFER_FLAG_NONE);
+
+    expect(mappedBuffer0.result).toBe(core.RESULT_OK);
+
+    let dupedBufferHandle = core.duplicateBufferHandle(sharedBuffer.handle,
+        core.DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE);
+
+    expect(dupedBufferHandle.result).toBe(core.RESULT_OK);
+    expect(core.isHandle(dupedBufferHandle.handle)).toBeTruthy();
+
+    let mappedBuffer1 = core.mapBuffer(dupedBufferHandle.handle,
+                                       offset,
+                                       buffer_size,
+                                       core.MAP_BUFFER_FLAG_NONE);
+
+    expect(mappedBuffer1.result).toBe(core.RESULT_OK);
+
+    let buffer0 = new Uint8Array(mappedBuffer0.buffer);
+    let buffer1 = new Uint8Array(mappedBuffer1.buffer);
+    for(let i = 0; i < buffer0.length; ++i) {
+      buffer0[i] = i;
+      expect(buffer1[i]).toBe(i);
+    }
+
+    expect(core.unmapBuffer(mappedBuffer0.buffer)).toBe(core.RESULT_OK);
+    expect(core.unmapBuffer(mappedBuffer1.buffer)).toBe(core.RESULT_OK);
+
+    expect(core.close(dupedBufferHandle.handle)).toBe(core.RESULT_OK);
+    expect(core.close(sharedBuffer.handle)).toBe(core.RESULT_OK);
+  }
+
 });