Initial implementation of Cronet Async API.

components/cronet/android/cronet_url_request.cc

 // 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/chromium_url_request.h"
+#include "components/cronet/android/cronet_url_request.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/macros.h"
-#include "components/cronet/android/url_request_adapter.h"
-#include "components/cronet/android/url_request_context_adapter.h"
-#include "jni/ChromiumUrlRequest_jni.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"
 
 using base::android::ConvertUTF8ToJavaString;
 
 namespace cronet {
 namespace {
 
 net::RequestPriority ConvertRequestPriority(jint request_priority) {
   switch (request_priority) {
-    case REQUEST_PRIORITY_IDLE:
+    case CRONET_REQUEST_PRIORITY_IDLE:
       return net::IDLE;
-    case REQUEST_PRIORITY_LOWEST:
+    case CRONET_REQUEST_PRIORITY_LOWEST:
       return net::LOWEST;
-    case REQUEST_PRIORITY_LOW:
+    case CRONET_REQUEST_PRIORITY_LOW:
       return net::LOW;
-    case REQUEST_PRIORITY_MEDIUM:
+    case CRONET_REQUEST_PRIORITY_MEDIUM:
       return net::MEDIUM;
-    case REQUEST_PRIORITY_HIGHEST:
+    case CRONET_REQUEST_PRIORITY_HIGHEST:
       return net::HIGHEST;
     default:
       return net::LOWEST;
   }
 }
-
-void SetPostContentType(JNIEnv* env,
-                        URLRequestAdapter* request,
-                        jstring content_type) {
-  DCHECK(request != NULL);
-
-  std::string method_post("POST");
-  request->SetMethod(method_post);
-
-  std::string content_type_header("Content-Type");
-  std::string content_type_string(
-      base::android::ConvertJavaStringToUTF8(env, content_type));
-
-  request->AddHeader(content_type_header, content_type_string);
-}
-
-// A delegate of URLRequestAdapter that delivers callbacks to the Java layer.
-class JniURLRequestAdapterDelegate
-    : public URLRequestAdapter::URLRequestAdapterDelegate {
+// A delegate of CronetURLRequestAdapter that delivers callbacks to the Java
+// layer.
+class JniCronetURLRequestAdapterDelegate
+    : public CronetURLRequestAdapter::CronetURLRequestAdapterDelegate {
  public:
-  JniURLRequestAdapterDelegate(JNIEnv* env, jobject owner) {
+  JniCronetURLRequestAdapterDelegate(JNIEnv* env, jobject owner) {
     owner_ = env->NewGlobalRef(owner);
   }
 
-  virtual void OnResponseStarted(URLRequestAdapter* request) OVERRIDE {
+  virtual void OnRedirect(CronetURLRequestAdapter* request,
+                          const GURL& newLocation) OVERRIDE {
     JNIEnv* env = base::android::AttachCurrentThread();
-    cronet::Java_ChromiumUrlRequest_onResponseStarted(env, owner_);
+    cronet::Java_CronetUrlRequest_onRedirect(
+        env,
+        owner_,
+        ConvertUTF8ToJavaString(env, newLocation.spec()).Release());
   }
 
-  virtual void OnBytesRead(URLRequestAdapter* request) OVERRIDE {
-    int bytes_read = request->bytes_read();
-    if (bytes_read != 0) {
-      JNIEnv* env = base::android::AttachCurrentThread();
+  virtual void OnResponseStarted(CronetURLRequestAdapter* request) OVERRIDE {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    cronet::Java_CronetUrlRequest_onResponseStarted(env, owner_);

[mmenke, 2014/10/02 15:24:09]

Should check if request->status().is_success() is true.  If not, should call
onError.

[mef, 2014/10/02 22:07:42]

Per discussion moved status checks to cronet_url_request_adapter.cc (also
below).

+  }
+
+  virtual void OnBytesRead(CronetURLRequestAdapter* request,
+                           int bytes_read) OVERRIDE {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    if (bytes_read >= 0) {

[mmenke, 2014/10/02 15:24:09]

"&& request_->status().is_success()"

[mef, 2014/10/02 22:07:42]

Done.

       base::android::ScopedJavaLocalRef<jobject> java_buffer(
           env, env->NewDirectByteBuffer(request->Data(), bytes_read));
-      cronet::Java_ChromiumUrlRequest_onBytesRead(
+      cronet::Java_CronetUrlRequest_onDataReceived(
           env, owner_, java_buffer.obj());
+    } else {
+      cronet::Java_CronetUrlRequest_onError(env, owner_, request->error_code());
     }
   }
 
-  virtual void OnRequestFinished(URLRequestAdapter* request) OVERRIDE {
+  virtual void OnRequestFinished(CronetURLRequestAdapter* request,
+                                 bool canceled) OVERRIDE {
     JNIEnv* env = base::android::AttachCurrentThread();
-    cronet::Java_ChromiumUrlRequest_finish(env, owner_);
-  }
-
-  virtual int ReadFromUploadChannel(net::IOBuffer* buf,
-                                    int buf_length) OVERRIDE {
-    JNIEnv* env = base::android::AttachCurrentThread();
-    base::android::ScopedJavaLocalRef<jobject> java_buffer(
-        env, env->NewDirectByteBuffer(buf->data(), buf_length));
-    jint bytes_read = cronet::Java_ChromiumUrlRequest_readFromUploadChannel(
-        env, owner_, java_buffer.obj());
-    return bytes_read;
+    cronet::Java_CronetUrlRequest_onComplete(env, owner_,
+                                             canceled ? JNI_TRUE : JNI_FALSE );
   }
 
  protected:
-  virtual ~JniURLRequestAdapterDelegate() {
+  virtual ~JniCronetURLRequestAdapterDelegate() {
     JNIEnv* env = base::android::AttachCurrentThread();
     env->DeleteGlobalRef(owner_);
   }
 
  private:
   jobject owner_;
 
-  DISALLOW_COPY_AND_ASSIGN(JniURLRequestAdapterDelegate);
+  DISALLOW_COPY_AND_ASSIGN(JniCronetURLRequestAdapterDelegate);
 };
 
 }  // namespace
 
 // Explicitly register static JNI functions.
-bool ChromiumUrlRequestRegisterJni(JNIEnv* env) {
+bool CronetUrlRequestRegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 static jlong CreateRequestAdapter(JNIEnv* env,
                                   jobject object,
                                   jlong urlRequestContextAdapter,

[mmenke, 2014/10/02 15:24:09]

We should probably be using C++ style guide style for all arguments.

[mef, 2014/10/02 22:07:42]

Done.

                                   jstring url_string,
                                   jint priority) {
-  URLRequestContextAdapter* context =
-      reinterpret_cast<URLRequestContextAdapter*>(urlRequestContextAdapter);
+  CronetURLRequestContextAdapter* context =
+      reinterpret_cast<CronetURLRequestContextAdapter*>(
+          urlRequestContextAdapter);
   DCHECK(context != NULL);
 
   GURL url(base::android::ConvertJavaStringToUTF8(env, url_string));
 
   VLOG(1) << "New chromium network request: " << url.possibly_invalid_spec();
 
-  URLRequestAdapter* adapter =
-      new URLRequestAdapter(context,
-                            new JniURLRequestAdapterDelegate(env, object),
-                            url,
-                            ConvertRequestPriority(priority));
+  CronetURLRequestAdapter* adapter = new CronetURLRequestAdapter(
+      context,
+      new JniCronetURLRequestAdapterDelegate(env, object),
+      url,
+      ConvertRequestPriority(priority));
 
   return reinterpret_cast<jlong>(adapter);
 }
 
 // synchronized
 static void AddHeader(JNIEnv* env,
                       jobject object,
                       jlong urlRequestAdapter,
                       jstring name,
                       jstring value) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   DCHECK(request);
 
   std::string name_string(base::android::ConvertJavaStringToUTF8(env, name));
   std::string value_string(base::android::ConvertJavaStringToUTF8(env, value));
 
   request->AddHeader(name_string, value_string);
 }
 
-static void SetMethod(JNIEnv* env,
-                      jobject object,
-                      jlong urlRequestAdapter,
-                      jstring method) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+static void SetHttpMethod(JNIEnv* env,
+                          jobject object,
+                          jlong urlRequestAdapter,
+                          jstring method) {
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   DCHECK(request);
 
   std::string method_string(
       base::android::ConvertJavaStringToUTF8(env, method));
 
   request->SetMethod(method_string);
 }
 
-static void SetUploadData(JNIEnv* env,
-                          jobject object,
-                          jlong urlRequestAdapter,
-                          jstring content_type,
-                          jbyteArray content) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
-  SetPostContentType(env, request, content_type);
-
-  if (content != NULL) {
-    jsize size = env->GetArrayLength(content);
-    if (size > 0) {
-      jbyte* content_bytes = env->GetByteArrayElements(content, NULL);
-      request->SetUploadContent(reinterpret_cast<const char*>(content_bytes),
-                                size);
-      env->ReleaseByteArrayElements(content, content_bytes, 0);
-    }
-  }
-}
-
-static void SetUploadChannel(JNIEnv* env,
-                             jobject object,
-                             jlong urlRequestAdapter,
-                             jstring content_type,
-                             jlong content_length) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
-  SetPostContentType(env, request, content_type);
-
-  request->SetUploadChannel(env, content_length);
-}
-
-static void EnableChunkedUpload(JNIEnv* env,
-                               jobject object,
-                               jlong urlRequestAdapter,
-                               jstring content_type) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
-  SetPostContentType(env, request, content_type);
-
-  request->EnableChunkedUpload();
-}
-
-static void AppendChunk(JNIEnv* env,
-                        jobject object,
-                        jlong urlRequestAdapter,
-                        jobject chunk_byte_buffer,
-                        jint chunk_size,
-                        jboolean is_last_chunk) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
-  DCHECK(chunk_byte_buffer != NULL);
-
-  void* chunk = env->GetDirectBufferAddress(chunk_byte_buffer);
-  request->AppendChunk(
-      reinterpret_cast<const char*>(chunk), chunk_size, is_last_chunk);
-}
-
 /* synchronized */

[mmenke, 2014/10/02 15:24:09]

None of these are synchronized, are they?

[mef, 2014/10/02 22:07:42]

Done.

 static void Start(JNIEnv* env, jobject object, jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request != NULL) {
     request->Start();
   }
 }
 
 /* synchronized */
 static void DestroyRequestAdapter(JNIEnv* env,
                                   jobject object,
                                   jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request != NULL) {
     request->Destroy();
   }
 }
 
 /* synchronized */
 static void Cancel(JNIEnv* env, jobject object, jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request != NULL) {
     request->Cancel();
   }
 }
 
+static void ReceiveData(JNIEnv* env, jobject jcaller, jlong urlRequestAdapter) {
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
+  if (request != NULL) {
+    request->ReadData();
+  }

[mmenke, 2014/10/02 15:24:08]

nit:  --braces.  (Goes for all the one-line if statements)

[mef, 2014/10/02 22:07:42]

Done.

+}
+
+static void FollowDeferredRedirect(JNIEnv* env,
+                                   jobject jcaller,
+                                   jlong urlRequestAdapter) {
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
+  if (request != NULL) {
+    request->FollowDeferredRedirect();
+  }
+}
+
 static jint GetErrorCode(JNIEnv* env, jobject object, jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   int error_code = request->error_code();
   switch (error_code) {
     // TODO(mef): Investigate returning success on positive values, too, as
     // they technically indicate success.
     case net::OK:
-      return REQUEST_ERROR_SUCCESS;
+      return CRONET_REQUEST_ERROR_SUCCESS;
 
     // TODO(mef): Investigate this. The fact is that Chrome does not do this,
     // and this library is not just being used for downloads.
 
     // Comment from src/content/browser/download/download_resource_handler.cc:
     // ERR_CONTENT_LENGTH_MISMATCH and ERR_INCOMPLETE_CHUNKED_ENCODING are
     // allowed since a number of servers in the wild close the connection too
     // early by mistake. Other browsers - IE9, Firefox 11.0, and Safari 5.1.4 -
     // treat downloads as complete in both cases, so we follow their lead.
     case net::ERR_CONTENT_LENGTH_MISMATCH:
     case net::ERR_INCOMPLETE_CHUNKED_ENCODING:
-      return REQUEST_ERROR_SUCCESS;
+      return CRONET_REQUEST_ERROR_SUCCESS;
 
     case net::ERR_INVALID_URL:
     case net::ERR_DISALLOWED_URL_SCHEME:
     case net::ERR_UNKNOWN_URL_SCHEME:
-      return REQUEST_ERROR_MALFORMED_URL;
+      return CRONET_REQUEST_ERROR_MALFORMED_URL;
 
     case net::ERR_CONNECTION_TIMED_OUT:
-      return REQUEST_ERROR_CONNECTION_TIMED_OUT;
+      return CRONET_REQUEST_ERROR_CONNECTION_TIMED_OUT;
 
     case net::ERR_NAME_NOT_RESOLVED:
-      return REQUEST_ERROR_UNKNOWN_HOST;
+      return CRONET_REQUEST_ERROR_UNKNOWN_HOST;
   }
-  return REQUEST_ERROR_UNKNOWN;
+  return CRONET_REQUEST_ERROR_UNKNOWN;
 }
 
 static jstring GetErrorString(JNIEnv* env,
                               jobject object,
                               jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   int error_code = request->error_code();
   char buffer[200];
   std::string error_string = net::ErrorToString(error_code);
   snprintf(buffer,
            sizeof(buffer),
            "System error: %s(%d)",
            error_string.c_str(),
            error_code);
   return ConvertUTF8ToJavaString(env, buffer).Release();
 }
 
 static jint GetHttpStatusCode(JNIEnv* env,
                               jobject object,
                               jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   return request->http_status_code();
 }
 
 static jstring GetContentType(JNIEnv* env,
                               jobject object,
                               jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request == NULL) {
     return NULL;
   }
   std::string type = request->content_type();
   if (!type.empty()) {
     return ConvertUTF8ToJavaString(env, type.c_str()).Release();
   } else {
     return NULL;
   }
 }
 
 static jlong GetContentLength(JNIEnv* env,
                               jobject object,
                               jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request == NULL) {
     return 0;
   }
   return request->content_length();
 }
 
 static jstring GetHeader(JNIEnv* env,
                          jobject object,
                          jlong urlRequestAdapter,
                          jstring name) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request == NULL) {
     return NULL;
   }
 
   std::string name_string = base::android::ConvertJavaStringToUTF8(env, name);
   std::string value = request->GetHeader(name_string);
   if (!value.empty()) {
     return ConvertUTF8ToJavaString(env, value.c_str()).Release();
   } else {
     return NULL;
   }
 }
 
 static void GetAllHeaders(JNIEnv* env,
                           jobject object,
                           jlong urlRequestAdapter,
                           jobject headersMap) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request == NULL)
     return;
 
   net::HttpResponseHeaders* headers = request->GetResponseHeaders();
   if (headers == NULL)
     return;
 
   void* iter = NULL;
   std::string header_name;
   std::string header_value;
   while (headers->EnumerateHeaderLines(&iter, &header_name, &header_value)) {
     ScopedJavaLocalRef<jstring> name =
         ConvertUTF8ToJavaString(env, header_name);
     ScopedJavaLocalRef<jstring> value =
         ConvertUTF8ToJavaString(env, header_value);
-    Java_ChromiumUrlRequest_onAppendResponseHeader(
+    Java_CronetUrlRequest_onAppendResponseHeader(
         env, object, headersMap, 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(env, headers->GetStatusLine());
-  Java_ChromiumUrlRequest_onAppendResponseHeader(
+  Java_CronetUrlRequest_onAppendResponseHeader(
       env, object, headersMap, NULL, status_line.Release());
 }
 
 static jstring GetNegotiatedProtocol(JNIEnv* env,
                                      jobject object,
                                      jlong urlRequestAdapter) {
-  URLRequestAdapter* request =
-      reinterpret_cast<URLRequestAdapter*>(urlRequestAdapter);
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
   if (request == NULL)
     return ConvertUTF8ToJavaString(env, "").Release();
 
   std::string negotiated_protocol = request->GetNegotiatedProtocol();
   return ConvertUTF8ToJavaString(env, negotiated_protocol.c_str()).Release();
 }
 
+static jboolean GetWasCached(JNIEnv* env,
+                             jobject jcaller,
+                             jlong urlRequestAdapter) {
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
+  if (request == NULL)
+    return JNI_FALSE;
+
+  return request->GetWasCached() ? JNI_TRUE : JNI_FALSE;
+}
+
+static jlong GetTotalReceivedBytes(JNIEnv* env,
+                                   jobject jcaller,
+                                   jlong urlRequestAdapter) {
+  CronetURLRequestAdapter* request =
+      reinterpret_cast<CronetURLRequestAdapter*>(urlRequestAdapter);
+  if (request == NULL) {
+    return 0;
+  }
+  return request->GetTotalReceivedBytes();
+}
+
 }  // namespace cronet