Mojo + NaCl prototype.

mojo/public/cpp/system/handle.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_SYSTEM_HANDLE_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_HANDLE_H_
 
 #include <assert.h>
 #include <limits>
 
@@ skipping 175 matching lines @@
 
 // Should have zero overhead.
 MOJO_COMPILE_ASSERT(sizeof(Handle) == sizeof(MojoHandle),
                     bad_size_for_cpp_Handle);
 
 // The scoper should also impose no more overhead.
 typedef ScopedHandleBase<Handle> ScopedHandle;
 MOJO_COMPILE_ASSERT(sizeof(ScopedHandle) == sizeof(Handle),
                     bad_size_for_cpp_ScopedHandle);
 
-inline MojoResult Wait(const Handle& handle,
+inline MojoResult Wait(Handle handle,
                        MojoHandleSignals signals,
                        MojoDeadline deadline) {
   return MojoWait(handle.value(), signals, deadline);
 }
 
 // |HandleVectorType| and |FlagsVectorType| should be similar enough to
 // |std::vector<Handle>| and |std::vector<MojoHandleSignals>|, respectively:
 //  - They should have a (const) |size()| method that returns an unsigned type.
 //  - They must provide contiguous storage, with access via (const) reference to
 //    that storage provided by a (const) |operator[]()| (by reference).
@@ skipping 23 matching lines @@
 // goes out of scope.
 template <class HandleType>
 inline void Close(ScopedHandleBase<HandleType> /*handle*/) {}
 
 // Most users should typically use |Close()| (above) instead.
 inline MojoResult CloseRaw(Handle handle) {
   return MojoClose(handle.value());
 }
 
 // Strict weak ordering, so that |Handle|s can be used as keys in |std::map|s,
-// etc.
-inline bool operator<(const Handle& a, const Handle& b) {
+inline bool operator<(const Handle a, const Handle b) {
   return a.value() < b.value();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_HANDLE_H_