[Cronet] Initial implementation of HttpURLConnection

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

+// 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 java.io.IOException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * A package protected MessageLoop class for use in
+ * {@link CronetHttpURLConnection}.
+ */
+final class MessageLoop {
+    private final BlockingQueue<Runnable> mQueue;
+    // A reusable runnable to quit the message loop.
+    private final Runnable mQuitTask;
+    // Indicates whether this message loop is currently running.
+    private boolean mLoopRunning;
+
+    public MessageLoop() {
+        mQueue = new LinkedBlockingQueue<Runnable>();
+        mQuitTask = new Runnable() {
+            @Override
+            public void run() {
+                mLoopRunning = false;
+            }
+        };
+    }
+
+    /**
+     * Runs the message loop. Be sure to call {@link MessageLoop#postQuitTask()}
+     * to end the loop.
+     * @throws IOException
+     */
+    public void loop() throws IOException {
+        if (mLoopRunning) {
+            throw new IllegalStateException(
+                    "Cannot run loop when it is already running.");
+        }
+        mLoopRunning = true;
+        while (mLoopRunning) {
+            try {
+                Runnable task = mQueue.take(); // Blocks if the queue is empty.
+                task.run();
+            } catch (InterruptedException e) {
+                throw new IOException(e);

[mmenke, 2014/12/02 19:01:49]

This doesn't support resumption after an InterruptedException is thrown (If
there's a quit message in the queue, for instance, the next attempt to run the
loop quits instantly).  Do other implementations allow more data to be read
after an interrupted exception is thrown?

[xunjieli, 2014/12/02 20:35:34]

OkHttp's implementation retries until the request succeeds
(http://androidxref.com/4.4.3_r1.1/xref/external/okhttp/src/main/java/com/squa...).
However, if it encounters an non-recoverable IOException, okHttp just rethrows
it to the caller. 
The reason that we have this InterruptedException here is that we are using a
LinkedBlockingQueue which blocks when there is no task to run. OkHttp's does not
have a blocking queue, so it does not need to handle InterruptedException
explicitly.

I think it might be safe for now to just treat InterruptedException as an
unrecoverable IOException, since it might be the caller who explicitly
interrupts the thread. From the documentation
(https://docs.oracle.com/javase/tutorial/essential/concurrency/interrupt.html),
it does not mention anything about resuming. Also the Thread#resume() method is
deprecated (see
http://developer.android.com/reference/java/lang/Thread.html#resume()), so we
probably don't need to worry about resuming.

[mmenke, 2014/12/02 20:51:07]

We should throw an exception of some sort, then, on read attempts after the loop
has thrown an exception.

+            }
+        }
+    }
+
+    /**
+     * Posts a reusable runnable, {@link #mQuitTask} to quit the loop. This
+     * causes the {@link #loop()} to terminate after processing all currently
+     * enqueued messages.
+     * @throws IOException
+     */
+    public void postQuitTask() throws IOException {
+        try {
+            mQueue.put(mQuitTask);
+        } catch (InterruptedException e) {
+            throw new IOException(e);
+        }
+    }
+
+    /**
+     * Posts a task to the message loop.
+     * @throws IOException
+     */
+    public void postTask(Runnable task) throws IOException {
+        if (task == null) {
+            throw new IllegalArgumentException();
+        }
+        try {
+            mQueue.put(task);
+        } catch (InterruptedException e) {
+            throw new IOException(e);
+        }
+    }
+}