Fix win64 build failure on size truncation

mojo/public/bindings/js/core.cc

 // 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.
 
 #include "mojo/public/bindings/js/core.h"
 
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
@@ skipping 42 matching lines @@
   if (!args.GetNext(&handles) ||
       !args.GetNext(&flags) ||
       !args.GetNext(&deadline)) {
     return args.ThrowError();
   }
 
   if (handles.size() != flags.size())
     return args.ThrowTypeError("Arrays must have the same length.");
 
   args.Return(mojo::WaitMany(handles.data(), flags.data(),
-                             handles.size(), deadline));
+                             static_cast<uint32_t>(handles.size()), deadline));
 }
 
 void CreateMessagePipe(const v8::FunctionCallbackInfo<v8::Value>& info) {
   gin::Arguments args(info);
 
   mojo::Handle handle_0 = mojo::kInvalidHandle;
   mojo::Handle handle_1 = mojo::kInvalidHandle;
   MojoResult result = mojo::CreateMessagePipe(&handle_0, &handle_1);
 
   gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(info.GetIsolate());
@@ skipping 11 matching lines @@
   std::vector<mojo::Handle> handles;
   MojoWriteMessageFlags flags = MOJO_WRITE_MESSAGE_FLAG_NONE;
 
   if (!args.GetNext(&handle) ||
       !args.GetNext(&buffer) ||
       !args.GetNext(&handles) ||
       !args.GetNext(&flags)) {
     return args.ThrowError();
   }
 
-  args.Return(mojo::WriteMessage(handle, buffer.bytes(), buffer.num_bytes(),
-                                 handles.data(), handles.size(), flags));
+  args.Return(mojo::WriteMessage(handle, buffer.bytes(),
+                                 static_cast<uint32_t>(buffer.num_bytes()),
+                                 handles.data(),
+                                 static_cast<uint32_t>(handles.size()),
+                                 flags));
 }
 
 void ReadMessage(const v8::FunctionCallbackInfo<v8::Value>& info) {
   gin::Arguments args(info);
 
   mojo::Handle handle = mojo::kInvalidHandle;
   gin::ArrayBufferView buffer(args.isolate());
   uint32_t num_handles = 0;
   MojoReadMessageFlags flags = MOJO_READ_MESSAGE_FLAG_NONE;
 
   if (!args.GetNext(&handle) ||
       !args.GetNext(&buffer) ||
       !args.GetNext(&num_handles) ||
       !args.GetNext(&flags)) {
     return args.ThrowError();
   }
 
-  uint32_t num_bytes = buffer.num_bytes();
+  uint32_t num_bytes = static_cast<uint32_t>(buffer.num_bytes());
   std::vector<mojo::Handle> handles(num_handles);
   MojoResult result = mojo::ReadMessage(handle, buffer.bytes(), &num_bytes,
                                         handles.data(), &num_handles, flags);
   handles.resize(num_handles);
 
   // TODO(abarth): We should benchmark this codepath to make sure it's ok to
   // allocate all this memory on each read.
   gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(info.GetIsolate());
   dictionary.Set("result", result);
   dictionary.Set("bytesRead", num_bytes);
@@ skipping 80 matching lines @@
                gin::ConvertToV8(isolate, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
     data->SetObjectTemplate(&g_core_wrapper_info, templ);
   }
 
   return templ;
 }
 
 }  // namespace js
 }  // namespace mojo