Rectify our use of std::nullptr_t, inclusions of <stddef.h>/<cstddef>.

mojo/public/cpp/bindings/interface_ptr.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_BINDINGS_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_
 
 #include <algorithm>
+#include <cstddef>
 
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/lib/interface_ptr_internal.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 // A pointer to a local proxy of a remote Interface implementation. Uses a
 // message pipe to communicate with the remote implementation, and automatically
 // closes the pipe and deletes the proxy on destruction. The pointer must be
 // bound to a message pipe before the interface methods can be called.
 //
 // This class is thread hostile, as is the local proxy it manages. All calls to
 // this class or the proxy should be from the same thread that created it. If
 // you need to move the proxy to a different thread, extract the
 // InterfacePtrInfo (containing just the message pipe and any version
 // information) using PassInterface(), pass it to a different thread, and
 // create and bind a new InterfacePtr from that thread.
 template <typename Interface>
 class InterfacePtr {
  public:
   // Constructs an unbound InterfacePtr.
   InterfacePtr() {}
-  InterfacePtr(decltype(nullptr)) {}
+  InterfacePtr(std::nullptr_t) {}
 
   // Takes over the binding of another InterfacePtr.
   InterfacePtr(InterfacePtr&& other) {
     internal_state_.Swap(&other.internal_state_);
   }
 
   // Takes over the binding of another InterfacePtr, and closes any message pipe
   // already bound to this pointer.
   InterfacePtr& operator=(InterfacePtr&& other) {
     reset();
     internal_state_.Swap(&other.internal_state_);
     return *this;
   }
 
   // Assigning nullptr to this class causes it to close the currently bound
   // message pipe (if any) and returns the pointer to the unbound state.
-  InterfacePtr& operator=(decltype(nullptr)) {
+  InterfacePtr& operator=(std::nullptr_t) {
     reset();
     return *this;
   }
 
   // Closes the bound message pipe (if any) on destruction.
   ~InterfacePtr() {}
 
   // Binds the InterfacePtr to a remote implementation of Interface. The
   // |waiter| is used for receiving notifications when there is data to read
   // from the message pipe. For most callers, the default |waiter| will be
@@ skipping 118 matching lines @@
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   InterfacePtr<Interface> ptr;
   if (info.is_valid())
     ptr.Bind(info.Pass(), waiter);
   return ptr;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_