Use OnceCallback for Mojo binding connection error handlers.

mojo/public/cpp/bindings/README.md

 # Mojo C++ Bindings API
 This document is a subset of the [Mojo documentation](/mojo).
 
 [TOC]
 
 ## Overview
 The Mojo C++ Bindings API leverages the
 [C++ System API](/mojo/public/cpp/system) to provide a more natural set of
 primitives for communicating over Mojo message pipes. Combined with generated
 code from the [Mojom IDL and bindings generator](/mojo/public/tools/bindings),
@@ skipping 371 matching lines @@
 All message pipe-binding C++ objects (*e.g.*, `mojo::Binding<T>`,
 `mojo::InterfacePtr<T>`, *etc.*) support setting their connection error handler
 via a `set_connection_error_handler` method.
 
 We can set up another end-to-end `Logger` example to demonstrate error handler
 invocation:
 
 ``` cpp
 sample::mojom::LoggerPtr logger;
 LoggerImpl impl(mojo::MakeRequest(&logger));
-impl.set_connection_error_handler(base::Bind([] { LOG(ERROR) << "Bye."; }));
+impl.set_connection_error_handler(base::BindOnce([] { LOG(ERROR) << "Bye."; }));
 logger->Log("OK cool");
 logger.reset();  // Closes the client end.
 ```
 
 As long as `impl` stays alive here, it will eventually receive the `Log` message
 followed immediately by an invocation of the bound callback which outputs
 `"Bye."`. Like all other bindings callbacks, a connection error handler will
 **never** be invoked once its corresponding binding object has been destroyed.
 
 In fact, suppose instead that `LoggerImpl` had set up the following error
 handler within its constructor:
 
 ``` cpp
 LoggerImpl::LoggerImpl(sample::mojom::LoggerRequest request)
     : binding_(this, std::move(request)) {
   binding_.set_connection_error_handler(
-      base::Bind(&LoggerImpl::OnError, base::Unretained(this)));
+      base::BindOnce(&LoggerImpl::OnError, base::Unretained(this)));
 }
 
 void LoggerImpl::OnError() {
   LOG(ERROR) << "Client disconnected! Purging log lines.";
   lines_.clear();
 }
 ```
 
 The use of `base::Unretained` is *safe* because the error handler will never be
 invoked beyond the lifetime of `binding_`, and `this` owns `binding_`.
@@ skipping 1002 matching lines @@
 
 ```cpp
 inline bool IsKnownEnumValue(Department value);
 ```
 
 ### Additional Documentation
 
 [Calling Mojo From Blink](https://www.chromium.org/developers/design-documents/mojo/calling-mojo-from-blink)
 :    A brief overview of what it looks like to use Mojom C++ bindings from
      within Blink code.