[Cronet] Change interface APIs to abstract classes

components/cronet/README.md

 # Quick Start Guide to Using Cronet
 Cronet is the networking stack of Chromium put into a library for use on
 mobile. This is the same networking stack that is used in the Chrome browser
 by over a billion people. It offers an easy-to-use, high performance,
 standards-compliant, and secure way to perform HTTP requests. Cronet has support
 for both Android and iOS. On Android, Cronet offers its own Java asynchronous
 API as well as support for the [java.net.HttpURLConnection] API.
 This document gives a brief introduction to using these two Java APIs.
 
 ### Basics
-First you will need to implement the `UrlRequestListener` interface to handle
+First you will need to extend `UrlRequestListener` to handle
 events during the lifetime of a request. For example:
 
-    class MyListener implements UrlRequestListener {
+    class MyListener extends UrlRequestListener {
         @Override
         public void onReceivedRedirect(UrlRequest request,
                 ResponseInfo responseInfo, String newLocationUrl) {
             if (followRedirect) {
                 // Let's tell Cronet to follow the redirect!
                 mRequest.followRedirect();
             } else {
                 // Not worth following the redirect? Abandon the request.
                 mRequest.cancel();
             }
@@ skipping 45 matching lines @@
 
     UrlRequestContextConfig myConfig = new UrlRequestContextConfig();
     CronetUrlRequestContext myRequestContext =
             new CronetUrlRequestContext(getContext(), myConfig);
     Executor executor = Executors.newSingleThreadExecutor();
     MyListener listener = new MyListener();
     UrlRequest request = myRequestContext.createRequest(
             "https://www.example.com", listener, executor);
     request.start();
 
-In the above example, `MyListener` implements the `UrlRequestListener`
-interface. The request is started asynchronously. When the response is ready
-(fully or partially), and in the event of failures or redirects,
-`listener`'s methods will be invoked on `executor`'s thread to inform the
-client of the request state and/or response information.
+In the above example, `MyListener` extends `UrlRequestListener`. The request
+is started asynchronously. When the response is ready (fully or partially), and
+in the event of failures or redirects, `listener`'s methods will be invoked on
+`executor`'s thread to inform the client of the request state and/or response
+information.
 
 ### Downloading Data
 When Cronet fetches response headers from the server or gets them from the
 cache, `UrlRequestListener.onResponseStarted` will be invoked. To read the
 response body, the client should call `UrlRequest.read` and supply a
 [ByteBuffer] for Cronet to fill. Once a portion or all of
 the response body is read, `UrlRequestListener.onReadCompleted` will be invoked.
-The client may consume the data, or copy the contents of the `byteBuffer`
-elsewhere for use later. The data in `byteBuffer` is only guaranteed to be
-valid for the duration of the `UrlRequestListener.onReadCompleted` callback.
+The client may then read and consume the data within `byteBuffer`.
 Once the client is ready to consume more data, the client should call
 `UrlRequest.read` again. The process continues until
 `UrlRequestListener.onSucceeded` or `UrlRequestListener.onFailed` is invoked,
 which signals the completion of the request.
 
 ### Uploading Data
     MyUploadDataProvider myUploadDataProvider = new MyUploadDataProvider();
     request.setHttpMethod("POST");
     request.setUploadDataProvider(myUploadDataProvider, executor);
     request.start();
 
-In the above example, `MyUploadDataProvider` implements the
-`UploadDataProvider` interface. When Cronet is ready to send the request body,
+In the above example, `MyUploadDataProvider` extends `UploadDataProvider`.
+When Cronet is ready to send the request body,
 `myUploadDataProvider.read(UploadDataSink uploadDataSink,
 ByteBuffer byteBuffer)` will be invoked. The client will need to write the
 request body into `byteBuffer`. Once the client is done writing into
 `byteBuffer`, the client can let Cronet know by calling
 `uploadDataSink.onReadSucceeded`. If the request body doesn't fit into
 `byteBuffer`, the client can continue writing when `UploadDataProvider.read` is
 invoked again. For more details, please see the API reference.
 
 ### <a id=configuring-cronet></a> Configuring Cronet
 Various configuration options are available via the `UrlRequestContextConfig`
@@ skipping 42 matching lines @@
 see {@link org.chromium.net.urlconnection.CronetURLStreamHandlerFactory} for
 more information).
 You can configure Cronet and control caching through the
 `UrlRequestContextConfig` instance, `myConfig`
 (See [Configuring Cronet](#configuring-cronet) section), before you pass it
 into the `CronetURLStreamHandlerFactory` constructor.
 
 [ByteBuffer]: https://developer.android.com/reference/java/nio/ByteBuffer.html
 [chrome://net-internals#import]: chrome://net-internals#import
 [java.net.HttpURLConnection]: https://developer.android.com/reference/java/net/HttpURLConnection.html