[Cronet] Initial implementation of HttpURLConnection

components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java

Index: components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java
diff --git a/components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java b/components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c0ed64a6c2e30015ad7ad79aa3f5f71ffa4e3a9
--- /dev/null
+++ b/components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java
@@ -0,0 +1,213 @@
+// 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.
+
+package org.chromium.net.urlconnection;
+
+import org.chromium.net.ExtendedResponseInfo;
+import org.chromium.net.ResponseInfo;
+import org.chromium.net.UrlRequest;
+import org.chromium.net.UrlRequestContext;
+import org.chromium.net.UrlRequestException;
+import org.chromium.net.UrlRequestListener;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * An implementation of HttpURLConnection that uses Cronet to send requests and
+ * receive response. This class inherits a {@code connected} field from the
+ * superclass. That field indicates whether a connection has ever been
+ * attempted.
+ */
+public class CronetHttpURLConnection extends HttpURLConnection {
+
+    private final UrlRequestContext mUrlRequestContext;
+
+    private UrlRequest mRequest;
+
+    private ResponseInfo mResponseInfo;
+
+    private InputStream mResponseBody;
+
+    private final MessageLoop mMessageLoop;
+
+    private final BlockingQueue<MessageLoop.Message> mMessageQueue;
+
+
+    protected CronetHttpURLConnection(URL url,
+            UrlRequestContext urlRequestContext) {
+        super(url);
+        mUrlRequestContext = urlRequestContext;
+        mMessageQueue = new LinkedBlockingQueue<MessageLoop.Message>();
+        mMessageLoop = new MessageLoop(mMessageQueue);
+    }
+
+
+    /**
+     * Wrapper executor class which posts tasks to current looper.
+     */
+    private class HandlerThreadExecutor implements Executor {
+
+        public HandlerThreadExecutor() {
+        }
+
+        @Override
+        public void execute(Runnable command) {
+            try {
+                mMessageQueue.put(new MessageLoop.Message(command));
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Opens a connection to the resource.
+     */
+    @Override
+    public void connect() throws IOException {
+        maybeStartRequest();
+    }
+
+    /**
+     * Releases this connection so that its resources may be either reused or
+     * closed.
+     */
+    @Override
+    public void disconnect() {
+        if (mResponseBody != null) {
+            try {
+                mResponseBody.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Returns the response message returned by the remote HTTP server.
+     */
+    @Override
+    public String getResponseMessage() {
+        maybeStartRequest();
+        return mResponseInfo.getHttpStatusText();
+    }
+
+    /**
+     * Returns the response code returned by the remote HTTP server.
+     */
+    @Override
+    public int getResponseCode() {
+        maybeStartRequest();
+        return mResponseInfo.getHttpStatusCode();
+    }
+
+    /**
+     * Returns an InputStream for reading data from the resource pointed by this
+     * URLConnection.
+     */
+    @Override
+    public InputStream getInputStream() {
+        maybeStartRequest();
+        return mResponseBody;
+    }
+
+    /**
+     * Adds the given property to the request header.
+     */
+    @Override
+    public final void addRequestProperty(String key, String value) {
+        setRequestProperty(key, value);
+    }
+
+    /**
+     * Sets the value of the specified request header field.
+     */
+    @Override
+    public final void setRequestProperty(String key, String value) {
+        if (connected) {
+            throw new IllegalStateException(
+                    "Cannot set request property after connection is made");
+        }
+        maybeCreateRequest();
+        mRequest.addHeader(key, value);
+    }
+
+    /**
+     * Returns whether this connection uses a proxy server or not.
+     */
+    @Override
+    public boolean usingProxy() {
+        // TODO(xunjieli): implement this.
+        return false;
+    }
+
+    private class CronetUrlRequestListener implements UrlRequestListener {
+
+        public CronetUrlRequestListener() {
+        }
+
+        @Override
+        public void onResponseStarted(UrlRequest request, ResponseInfo info) {
+            mResponseInfo = info;
+        }
+
+        @Override
+        public void onDataReceived(UrlRequest request, ResponseInfo info,
+                ByteBuffer byteBuffer) {
+            mResponseInfo = info;
+            // TODO(xunjieli): handle streaming.
+            mResponseBody = new ByteBufferInputStream(byteBuffer);
+        }
+
+        @Override
+        public void onRedirect(UrlRequest request, ResponseInfo info,
+                String newLocationUrl) {
+            // TODO(xunjieli): handle redirect.
+            mResponseInfo = info;
+        }
+
+        @Override
+        public void onSucceeded(UrlRequest request, ExtendedResponseInfo info) {
+            mMessageLoop.quit();
+        }
+
+        @Override
+        public void onFailed(UrlRequest request, ResponseInfo info,
+                UrlRequestException exception) {
+            // TODO(xunjieli): handle failure.
+            mMessageLoop.quit();
+        }
+    }
+
+    /**
+     * Maybe starts {@code mRequest}, and waits for it to complete.
+     */
+    private void maybeStartRequest() {
+        if (connected) {
+            return;
+        }
+        maybeCreateRequest();
+        mRequest.start();
+        connected = true;
+        mMessageLoop.loop();
+    }
+
+    /**
+     * Maybe creates {@code mRequest} if it is null.
+     */
+    private void maybeCreateRequest() {
+        if (mRequest != null) {
+            return;
+        }
+        mRequest = mUrlRequestContext.createRequest(url.toString(),
+                new CronetUrlRequestListener(), new HandlerThreadExecutor());
+    }
+}