Initial implementation of Cronet Async API.

components/cronet/android/cronet_url_request.cc

Index: components/cronet/android/cronet_url_request.cc
diff --git a/components/cronet/android/cronet_url_request.cc b/components/cronet/android/cronet_url_request.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a297e33fd9c5bd9648c1511e7f83cf27c34b97f9
--- /dev/null
+++ b/components/cronet/android/cronet_url_request.cc
@@ -0,0 +1,283 @@
+// 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.
+
+#include "components/cronet/android/cronet_url_request.h"
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_string.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "components/cronet/android/cronet_url_request_adapter.h"
+#include "components/cronet/android/cronet_url_request_context_adapter.h"
+#include "jni/CronetUrlRequest_jni.h"
+#include "net/base/net_errors.h"
+#include "net/base/request_priority.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_util.h"
+
+using base::android::ConvertUTF8ToJavaString;
+
+namespace cronet {
+namespace {
+
+net::RequestPriority ConvertRequestPriority(jint request_priority) {
+  switch (request_priority) {
+    case CRONET_REQUEST_PRIORITY_IDLE:
+      return net::IDLE;
+    case CRONET_REQUEST_PRIORITY_LOWEST:
+      return net::LOWEST;
+    case CRONET_REQUEST_PRIORITY_LOW:
+      return net::LOW;
+    case CRONET_REQUEST_PRIORITY_MEDIUM:
+      return net::MEDIUM;
+    case CRONET_REQUEST_PRIORITY_HIGHEST:
+      return net::HIGHEST;
+    default:
+      return net::LOWEST;
+  }
+}
+
+// A delegate of CronetURLRequestAdapter that delivers callbacks to the Java
+// layer. Always called on Network Thread.

[mmenke, 2014/11/03 20:21:16]

nit:  on -> on the

[mef, 2014/11/03 21:23:37]

Done.

+class JniCronetURLRequestAdapterDelegate
+    : public CronetURLRequestAdapter::CronetURLRequestAdapterDelegate {
+ public:
+  JniCronetURLRequestAdapterDelegate(JNIEnv* jenv, jobject jowner) {

[mmenke, 2014/11/03 20:21:16]

I don't believe this should actually be j prefixed - the API doesn't actually
know if they directly come from Java.  At least I believe that's the standard we
discussed.

[mef, 2014/11/03 21:23:37]

Done.

+    owner_.Reset(jenv, jowner);
+  }
+
+  void OnRedirect(const GURL& new_location, int http_status_code) override {
+    JNIEnv* jenv = base::android::AttachCurrentThread();

[mmenke, 2014/11/03 20:21:16]

env is the name pretty much always used for JNIEnv, except in NCN util, which
should probably be changed to be consistent.  Should search your code and fix
all instances, rather than me pointing out all occurences.

[mef, 2014/11/03 21:23:37]

Done.

+    cronet::Java_CronetUrlRequest_onRedirect(
+        jenv,
+        owner_.obj(),
+        ConvertUTF8ToJavaString(jenv, new_location.spec()).Release(),
+        http_status_code);
+  }
+
+  void OnResponseStarted(int http_status_code) override {
+    JNIEnv* jenv = base::android::AttachCurrentThread();
+    cronet::Java_CronetUrlRequest_onResponseStarted(jenv, owner_.obj(),
+        http_status_code);

[mmenke, 2014/11/03 20:21:16]

Fix indent

[mef, 2014/11/03 21:23:37]

Done.

+  }
+
+  void OnBytesRead(unsigned char* bytes_buffer,
+                   int bytes_read) override {
+    JNIEnv* jenv = base::android::AttachCurrentThread();
+    base::android::ScopedJavaLocalRef<jobject> java_buffer(
+        jenv, jenv->NewDirectByteBuffer(bytes_buffer, bytes_read));
+    cronet::Java_CronetUrlRequest_onDataReceived(
+        jenv, owner_.obj(), java_buffer.obj());
+  }
+
+  void OnRequestFinished() override {
+    JNIEnv* jenv = base::android::AttachCurrentThread();
+    cronet::Java_CronetUrlRequest_onComplete(jenv, owner_.obj());
+  }
+
+  void OnError(int net_error) override {
+    JNIEnv* jenv = base::android::AttachCurrentThread();
+    cronet::Java_CronetUrlRequest_onError(
+        jenv,
+        owner_.obj(),
+        net_error,
+        ConvertUTF8ToJavaString(jenv, net::ErrorToString(net_error)).Release());
+  }
+
+ protected:

[mmenke, 2014/11/03 20:21:16]

Since nothing subclasses this class, this method should be public or private.

[mef, 2014/11/03 21:23:37]

Done.

+  ~JniCronetURLRequestAdapterDelegate() override {
+  }
+
+ private:
+  base::android::ScopedJavaGlobalRef<jobject> owner_;

[mmenke, 2014/11/03 20:21:16]

This isn't quite accurately named (And again, I think our round-robin ownership
is kinda weird here, and we get pretty much nothing from separating the Adapter
and the delegate).  Should have a comment that this actually owns the adapter.

[mef, 2014/11/03 21:23:37]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(JniCronetURLRequestAdapterDelegate);
+};
+
+}  // namespace
+
+// Explicitly register static JNI functions.
+bool CronetUrlRequestRegisterJni(JNIEnv* jenv) {
+  return RegisterNativesImpl(jenv);
+}
+
+static jlong CreateRequestAdapter(JNIEnv* jenv,

[mmenke, 2014/11/03 20:21:16]

These, too, always use env.  Looking over existing code, I find the j prefix to
calls from Java pretty uncommon, but as long as we're consistent in cronet, I'm
fine with them.

[xunjieli, 2014/11/03 20:27:49]

I still feel that using j prefix will potentially solve a lot of confusion down
the road. I am not very clear on whether to use "env" or "jenv", but IMO we
should use j prefix for all the rest. 

[mef, 2014/11/03 21:23:38]

I don't have strong preference, but I guess 'coming directly from java' is a
good rule for 'j' prefix.

+                                  jobject jurl_request,
+                                  jlong jurl_request_context_adapter,
+                                  jstring jurl_string,
+                                  jint jpriority) {
+  CronetURLRequestContextAdapter* context_adapter =
+      reinterpret_cast<CronetURLRequestContextAdapter*>(
+          jurl_request_context_adapter);
+  DCHECK(context_adapter);
+
+  GURL url(base::android::ConvertJavaStringToUTF8(jenv, jurl_string));
+
+  VLOG(1) << "New chromium network request_adapter: "
+          << url.possibly_invalid_spec();
+
+  scoped_ptr<CronetURLRequestAdapter::CronetURLRequestAdapterDelegate> delegate(
+      new JniCronetURLRequestAdapterDelegate(jenv, jurl_request));
+
+  CronetURLRequestAdapter* adapter = new CronetURLRequestAdapter(
+      context_adapter,
+      delegate.Pass(),
+      url,
+      ConvertRequestPriority(jpriority));
+
+  return reinterpret_cast<jlong>(adapter);
+}
+
+static jboolean AddHeader(JNIEnv* jenv,
+                          jobject jurl_request,
+                          jlong jurl_request_adapter,
+                          jstring jname,
+                          jstring jvalue) {
+  if (!jurl_request_adapter)

[mmenke, 2014/11/03 20:21:16]

This can't happen.  Fine to DCHECK on it.

[mef, 2014/11/03 21:23:37]

Done.

+    return JNI_FALSE;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  std::string name(base::android::ConvertJavaStringToUTF8(jenv, jname));
+  std::string value(base::android::ConvertJavaStringToUTF8(jenv, jvalue));
+  DCHECK(!request_adapter->IsOnNetworkThread());

[mmenke, 2014/11/03 20:21:16]

DCHECKs on input state should generally go first.

[mef, 2014/11/03 21:23:37]

Done.

+  if (!net::HttpUtil::IsValidHeaderName(name) ||
+      !net::HttpUtil::IsValidHeaderValue(value)) {
+    return JNI_FALSE;
+  }
+  request_adapter->AddRequestHeader(name, value);
+  return JNI_TRUE;
+}
+
+static jboolean SetHttpMethod(JNIEnv* jenv,
+                              jobject jurl_request,
+                              jlong jurl_request_adapter,
+                              jstring jmethod) {
+  if (!jurl_request_adapter)
+    return JNI_FALSE;

[mmenke, 2014/11/03 20:21:16]

This can't happen.  Fine to DCHECK on it.  This goes for all the calls in this
file, I believe - as long as we have the mutex when we call into C++, the
adapter can not be NULL.

[mef, 2014/11/03 21:23:38]

Done.

+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  std::string method(base::android::ConvertJavaStringToUTF8(jenv, jmethod));
+  DCHECK(!request_adapter->IsOnNetworkThread());

[mmenke, 2014/11/03 20:21:16]

DCHECKs should go first, when they can.  Goes for rest of file, too.

[mef, 2014/11/03 21:23:38]

Done.

+  // Http method is a token, just as header name.
+  if (!net::HttpUtil::IsValidHeaderName(method))
+    return JNI_FALSE;
+  request_adapter->set_method(method);
+  return JNI_TRUE;
+}
+
+static void Start(JNIEnv* jenv,
+                  jobject jurl_request,
+                  jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(!request_adapter->IsOnNetworkThread());
+  request_adapter->Start();
+}
+
+static void DestroyRequestAdapter(JNIEnv* jenv,
+                                  jobject jurl_request,
+                                  jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(!request_adapter->IsOnNetworkThread());
+  request_adapter->Destroy();
+}
+
+static void ReceiveData(JNIEnv* jenv,
+                        jobject jcaller,
+                        jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(!request_adapter->IsOnNetworkThread());
+  request_adapter->ReadData();
+}
+
+static void FollowDeferredRedirect(JNIEnv* jenv,
+                                   jobject jcaller,
+                                   jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(!request_adapter->IsOnNetworkThread());
+  request_adapter->FollowDeferredRedirect();
+}
+
+static void PopulateResponseHeaders(JNIEnv* jenv,
+                                    jobject jurl_request,
+                                    jlong jurl_request_adapter,
+                                    jobject jheaders_map) {
+  if (!jurl_request_adapter)
+    return;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(request_adapter);
+  DCHECK(request_adapter->IsOnNetworkThread());
+
+  net::HttpResponseHeaders* headers = request_adapter->GetResponseHeaders();
+  if (headers == nullptr)
+    return;
+
+  void* iter = nullptr;
+  std::string header_name;
+  std::string header_value;
+  while (headers->EnumerateHeaderLines(&iter, &header_name, &header_value)) {
+    ScopedJavaLocalRef<jstring> name =
+        ConvertUTF8ToJavaString(jenv, header_name);
+    ScopedJavaLocalRef<jstring> value =
+        ConvertUTF8ToJavaString(jenv, header_value);
+    Java_CronetUrlRequest_onAppendResponseHeader(
+        jenv, jurl_request, jheaders_map, name.Release(), value.Release());
+  }
+
+  // Some implementations (notably HttpURLConnection) include a mapping for the
+  // null key; in HTTP's case, this maps to the HTTP status line.
+  ScopedJavaLocalRef<jstring> status_line =
+      ConvertUTF8ToJavaString(jenv, headers->GetStatusLine());
+  Java_CronetUrlRequest_onAppendResponseHeader(
+      jenv, jurl_request, jheaders_map, nullptr, status_line.Release());
+}
+
+static jstring GetNegotiatedProtocol(JNIEnv* jenv,
+                                     jobject jurl_request,
+                                     jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return ConvertUTF8ToJavaString(jenv, std::string()).Release();
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(request_adapter->IsOnNetworkThread());
+  std::string negotiated_protocol = request_adapter->GetNegotiatedProtocol();
+  return ConvertUTF8ToJavaString(jenv, negotiated_protocol).Release();
+}
+
+static jboolean GetWasCached(JNIEnv* jenv,
+                             jobject jurl_request,
+                             jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return JNI_FALSE;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(request_adapter->IsOnNetworkThread());
+  return request_adapter->GetWasCached() ? JNI_TRUE : JNI_FALSE;
+}
+
+static jlong GetTotalReceivedBytes(JNIEnv* jenv,
+                                   jobject jurl_request,
+                                   jlong jurl_request_adapter) {
+  if (!jurl_request_adapter)
+    return 0;
+  CronetURLRequestAdapter* request_adapter =
+      reinterpret_cast<CronetURLRequestAdapter*>(jurl_request_adapter);
+  DCHECK(request_adapter->IsOnNetworkThread());
+  return request_adapter->GetTotalReceivedBytes();
+}
+
+}  // namespace cronet