Implement DISALLOW_COPY_AND_ASSIGN using = delete.

base/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.
 
 // This file contains macros and macro-like constructs (e.g., templates) that
 // are commonly used throughout Chromium source. (It may also contain things
 // that are closely related to things that are commonly used that belong in this
 // file.)
 
 #ifndef BASE_MACROS_H_
 #define BASE_MACROS_H_
 
 #include <stddef.h>  // For size_t.
 
 // Put this in the declarations for a class to be uncopyable.
 #define DISALLOW_COPY(TypeName) \
   TypeName(const TypeName&) = delete
 
 // Put this in the declarations for a class to be unassignable.
 #define DISALLOW_ASSIGN(TypeName) \
   void operator=(const TypeName&) = delete
 
 // A macro to disallow the copy constructor and operator= functions
 // This should be used in the private: declarations for a class

[Ryan Hamilton, 2016/05/25 14:10:06]

Presumably, this advice about private: is no longer correct?

[Peter Kasting, 2016/05/25 18:55:17]

No, this advice is still correct.  We have not made any changes to how the macro
should be used.

 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
-  TypeName(const TypeName&);               \
-  void operator=(const TypeName&)
+  TypeName(const TypeName&) = delete;      \
+  void operator=(const TypeName&) = delete
 
 // A macro to disallow all the implicit constructors, namely the
 // default constructor, copy constructor and operator= functions.
 //
 // This should be used in the private: declarations for a class

[Ryan Hamilton, 2016/05/25 14:10:06]

ditto

 // that wants to prevent anyone from instantiating it. This is
 // especially useful for classes containing only static methods.
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
   TypeName() = delete;                           \
   DISALLOW_COPY_AND_ASSIGN(TypeName)
 
 // The arraysize(arr) macro returns the # of elements in an array arr.  The
 // expression is a compile-time constant, and therefore can be used in defining
 // new arrays, for example.  If you use arraysize on a pointer by mistake, you
 // will get a compile-time error.  For the technical details, refer to
@@ skipping 35 matching lines @@
 
 // Use these to declare and define a static local variable (static T;) so that
 // it is leaked so that its destructors are not called at exit. If you need
 // thread-safe initialization, use base/lazy_instance.h instead.
 #define CR_DEFINE_STATIC_LOCAL(type, name, arguments) \
   static type& name = *new type arguments
 
 }  // base
 
 #endif  // BASE_MACROS_H_