ApplicationConnection devolution, part 2.1.

examples/echo/README.md

 Example Echo Client & Server
 ====
 
 This echo client/server demonstrate how to create and use a mojom interface,
 as well as demonstrating one way to communicate between mojo applications.
 
 For a deeper dive into this code, refer to the [Mojo
 Tutorial](https://docs.google.com/document/d/1mufrtxTk8w9qa3jcnlgqsYkWlyhwEpc7aWNaSOks7ug).
 
 ## Running the Echo Client & Server
@@ skipping 109 matching lines @@
 callback implementations being passed where necessary.
 
 ## Echo Server Structure
 
 The echo server, like the echo client, is implemented as an application. This
 means it has a `MojoMain` function, an `ApplicationRunner`, and an
 `ApplicationDelegate` actually implementing the core application.
 
 echo_server.cc contains three different types of servers, though only one can be
 used at a time. To try changing the server, uncomment one of the lines in
-MojoMain. These different `ApplicationDelegate` derivations demonstrate how
-differently the `InterfaceFactory` can be created.  Each server derives from
-`InterfaceFactory`, which implements an interface and binds it to incoming
-requests.
+MojoMain. These different `ApplicationDelegate` derivations demonstrate
+different ways in which incoming requests can be handled.
 
 All three servers, being `ApplicationDelegate` derivations, implement
 `ConfigureIncomingConnection` in the same way:
 
 ```
-connection->AddService<Echo>(this);
+connection->GetServiceProviderImpl().AddService<Echo>(
+    [this](const mojo::ConnectionContext& connection_context,
+           mojo::InterfaceRequest<Echo> echo_request) {
+      ...
+    });
 ```
 
-This should be read as "For any incoming connections to this server, use `this`
-as a factory to create the Echo interface".
-
-Each server's `Create` method will now be called when a new connection wants
-to access the Echo interface.
+This should be read as "For any incoming connections to this server, use the
+given lambda function use `this` to create the Echo interface".
 
 ### EchoImpl: The Interface Implementation
 
 All three implementations use the `EchoImpl` class, implementing the `Echo`
 interface we defined in our mojom file, which does what you would expect of an
 echo server: it sends back the supplied value String back to the client.
 
 ```
 callback.Run(value);
 ```
@@ skipping 20 matching lines @@
 This server creates an `EchoImpl` object, like the `SingletonServer`, but uses a
 single `Binding`, rather than a `BindingSet`. This means that when a new client
 connects to the OneAtATimeServer, the previous binding is closed, and a new
 binding is made between the new client and the interface implementation.
 
 The OneAtATimeServer demonstrates a pattern that should be avoided because it
 contains a race condition for multiple clients.  If a new client binds to the
 server before the first client managed to call EchoString, the first client's
 call would cause an error. Unless you have a specific use case for this
 behavior, it is advised to avoid creating a server like this.