[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 implement the `UrlRequestListener` class to handle

[xunjieli, 2015/09/03 04:32:02]

I am not sure... Should we also use "extend" instead of "implement" in
sentences? Loosely speaking, "implement" does convey the right idea, so I am not
sure if we need to change it here and elsewhere to use "extend" instead,  though
these two words are a bit different in the Java land and we probably should
avoid confusing those two when explaining?

[pauljensen, 2015/09/11 15:20:41]

Ya, I think we should stick with "implement" in English while the class is
mostly abstract members.  Even if only a minority of the class members are
abstract, "extend" doesn't seem to imply the right action, more like "override";
but for now when it's 100% abstract members, I think "implement" is the best
description of the action embedders will take.

Now that I read it, saying "implement the class" doesn't sound right; embedders
will be implementing a subclass.  I've reworded. PTAL.

[xunjieli, 2015/09/11 16:26:35]

Acknowledged. SGTM

 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`

[xunjieli, 2015/09/03 04:32:02]

Here, I also wonder whether we should s/implements/extends.

[pauljensen, 2015/09/11 15:20:41]

I feel the same way as on line 11.  I reworded like I did on line 11.

-interface. The request is started asynchronously. When the response is ready
+class. 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.
 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

[xunjieli, 2015/09/03 04:32:02]

And here.

[pauljensen, 2015/09/11 15:20:41]

I feel the same way as on line 11.  I reworded like I did on line 11.

-`UploadDataProvider` interface. When Cronet is ready to send the request body,
+`UploadDataProvider` class. 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