Make the suppressed copy/assignment operators in MOJO_MOVE_ONLY_TYPE take const refs.

mojo/public/cpp/system/macros.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.
 
 // Define a set of C++ specific macros.
 // Mojo C++ API users can assume that mojo/public/cpp/system/macros.h
 // includes mojo/public/c/system/macros.h.
 
 #ifndef MOJO_PUBLIC_CPP_SYSTEM_MACROS_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_MACROS_H_
@@ skipping 17 matching lines @@
 #endif
 }  // namespace internal
 }  // namespace mojo
 #define MOJO_ARRAYSIZE(array) (sizeof(::mojo::internal::ArraySizeHelper(array)))
 
 // Used to make a type move-only. See Chromium's base/move.h for more
 // details. The MoveOnlyTypeForCPP03 typedef is for Chromium's base/callback.h
 // to tell that this type is move-only.
 #define MOJO_MOVE_ONLY_TYPE(type)                                              \
  private:                                                                      \
-  type(type&);                                                                 \
-  void operator=(type&);                                                       \
+  type(const type&);                                                           \
+  void operator=(const type&);                                                 \
                                                                                \
  public:                                                                       \
   type&& Pass() MOJO_WARN_UNUSED_RESULT { return static_cast<type&&>(*this); } \
   typedef void MoveOnlyTypeForCPP03;                                           \
                                                                                \
  private:
 
 // The C++ standard requires that static const members have an out-of-class
 // definition (in a single compilation unit), but MSVC chokes on this (when
 // language extensions, which are required, are enabled). (You're only likely to
@@ skipping 22 matching lines @@
 // Used to explicitly mark the return value of a function as unused. (Use this
 // if you are really sure you don't want to do anything with the return value of
 // a function marked with |MOJO_WARN_UNUSED_RESULT|.
 template <typename T>
 inline void ignore_result(const T&) {
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_MACROS_H_