[Android WebView] Implement a better OnReceivedError callback

android_webview/native/aw_contents_io_thread_client_impl.cc

 // Copyright (c) 2012 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 "android_webview/native/aw_contents_io_thread_client_impl.h"
 
 #include <map>
 #include <utility>
 
 #include "android_webview/common/devtools_instrumentation.h"
 #include "android_webview/native/aw_web_resource_response_impl.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "jni/AwContentsIoThreadClient_jni.h"
+#include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaArrayOfStrings;
@@ skipping 109 matching lines @@
 }
 
 void ClientMapEntryUpdater::RenderFrameDeleted(RenderFrameHost* rfh) {
   RfhToIoThreadClientMap::GetInstance()->Erase(GetRenderFrameHostIdPair(rfh));
 }
 
 void ClientMapEntryUpdater::WebContentsDestroyed() {
   delete this;
 }
 
+struct WebResourceRequest {
+  ScopedJavaLocalRef<jstring> jstring_url;
+  bool is_main_frame;
+  bool has_user_gesture;
+  ScopedJavaLocalRef<jstring> jstring_method;
+  ScopedJavaLocalRef<jobjectArray> jstringArray_header_names;
+  ScopedJavaLocalRef<jobjectArray> jstringArray_header_values;
+
+  WebResourceRequest(JNIEnv* env, const net::URLRequest* request)
+      : jstring_url(ConvertUTF8ToJavaString(env, request->url().spec())),
+        jstring_method(ConvertUTF8ToJavaString(env, request->method())) {
+    const content::ResourceRequestInfo* info =
+        content::ResourceRequestInfo::ForRequest(request);
+    is_main_frame =
+        info && info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME;
+    has_user_gesture = info && info->HasUserGesture();
+
+    vector<string> header_names;
+    vector<string> header_values;
+    net::HttpRequestHeaders headers;
+    if (!request->GetFullRequestHeaders(&headers))
+      headers = request->extra_request_headers();
+    net::HttpRequestHeaders::Iterator headers_iterator(headers);
+    while (headers_iterator.GetNext()) {
+      header_names.push_back(headers_iterator.name());
+      header_values.push_back(headers_iterator.value());
+    }
+    jstringArray_header_names = ToJavaArrayOfStrings(env, header_names);
+    jstringArray_header_values = ToJavaArrayOfStrings(env, header_values);
+  }
+};
+
 } // namespace
 
 // AwContentsIoThreadClientImpl -----------------------------------------------
 
 // static
 scoped_ptr<AwContentsIoThreadClient>
 AwContentsIoThreadClient::FromID(int render_process_id, int render_frame_id) {
   pair<int, int> rfh_id(render_process_id, render_frame_id);
   IoThreadClientData client_data;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(rfh_id, &client_data))
@@ skipping 63 matching lines @@
     return AwContentsIoThreadClient::LOAD_DEFAULT;
 
   JNIEnv* env = AttachCurrentThread();
   return static_cast<AwContentsIoThreadClient::CacheMode>(
       Java_AwContentsIoThreadClient_getCacheMode(
           env, java_object_.obj()));
 }
 
 scoped_ptr<AwWebResourceResponse>
 AwContentsIoThreadClientImpl::ShouldInterceptRequest(
-    const GURL& location,
     const net::URLRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (java_object_.is_null())
     return scoped_ptr<AwWebResourceResponse>();
-  const content::ResourceRequestInfo* info =
-      content::ResourceRequestInfo::ForRequest(request);
-  bool is_main_frame = info &&
-      info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME;
-  bool has_user_gesture = info && info->HasUserGesture();
-
-  vector<string> headers_names;
-  vector<string> headers_values;
-  {
-    net::HttpRequestHeaders headers;
-    if (!request->GetFullRequestHeaders(&headers))
-      headers = request->extra_request_headers();
-    net::HttpRequestHeaders::Iterator headers_iterator(headers);
-    while (headers_iterator.GetNext()) {
-      headers_names.push_back(headers_iterator.name());
-      headers_values.push_back(headers_iterator.value());
-    }
-  }
 
   JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jstring> jstring_url =
-      ConvertUTF8ToJavaString(env, location.spec());
-  ScopedJavaLocalRef<jstring> jstring_method =
-      ConvertUTF8ToJavaString(env, request->method());
-  ScopedJavaLocalRef<jobjectArray> jstringArray_headers_names =
-      ToJavaArrayOfStrings(env, headers_names);
-  ScopedJavaLocalRef<jobjectArray> jstringArray_headers_values =
-      ToJavaArrayOfStrings(env, headers_values);
+  WebResourceRequest web_request(env, request);
+
   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
       "shouldInterceptRequest");
   ScopedJavaLocalRef<jobject> ret =
       Java_AwContentsIoThreadClient_shouldInterceptRequest(
           env,
           java_object_.obj(),
-          jstring_url.obj(),
-          is_main_frame,
-          has_user_gesture,
-          jstring_method.obj(),
-          jstringArray_headers_names.obj(),
-          jstringArray_headers_values.obj());
+          web_request.jstring_url.obj(),
+          web_request.is_main_frame,
+          web_request.has_user_gesture,
+          web_request.jstring_method.obj(),
+          web_request.jstringArray_header_names.obj(),
+          web_request.jstringArray_header_values.obj());
   if (ret.is_null())
     return scoped_ptr<AwWebResourceResponse>();
   return scoped_ptr<AwWebResourceResponse>(
       new AwWebResourceResponseImpl(ret));
 }
 
 bool AwContentsIoThreadClientImpl::ShouldBlockContentUrls() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (java_object_.is_null())
     return false;
@@ skipping 75 matching lines @@
   ScopedJavaLocalRef<jstring> jargs = ConvertUTF8ToJavaString(env, args);
 
   ScopedJavaLocalRef<jstring> jaccount;
   if (!account.empty())
     jaccount = ConvertUTF8ToJavaString(env, account);
 
   Java_AwContentsIoThreadClient_newLoginRequest(
       env, java_object_.obj(), jrealm.obj(), jaccount.obj(), jargs.obj());
 }
 
+void AwContentsIoThreadClientImpl::OnReceivedError(
+    const net::URLRequest* request) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (java_object_.is_null())
+    return;
+
+  JNIEnv* env = AttachCurrentThread();
+  WebResourceRequest web_request(env, request);
+
+  int error_code = request->status().error();
+  ScopedJavaLocalRef<jstring> jstring_description = ConvertUTF8ToJavaString(
+      env, net::ErrorToString(request->status().error()));
+
+  Java_AwContentsIoThreadClient_onReceivedError(
+      env,
+      java_object_.obj(),
+      web_request.jstring_url.obj(),
+      web_request.is_main_frame,
+      web_request.has_user_gesture,
+      web_request.jstring_method.obj(),
+      web_request.jstringArray_header_names.obj(),
+      web_request.jstringArray_header_values.obj(),
+      error_code,
+      jstring_description.obj());
+}
+
 void AwContentsIoThreadClientImpl::OnReceivedHttpError(
     const net::URLRequest* request,
     const net::HttpResponseHeaders* response_headers) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (java_object_.is_null())
     return;
 
-  vector<string> request_header_names;
-  vector<string> request_header_values;
-  {
-    net::HttpRequestHeaders headers;
-    if (!request->GetFullRequestHeaders(&headers))
-      headers = request->extra_request_headers();
-    net::HttpRequestHeaders::Iterator headers_iterator(headers);
-    while (headers_iterator.GetNext()) {
-      request_header_names.push_back(headers_iterator.name());
-      request_header_values.push_back(headers_iterator.value());
-    }
-  }
+  JNIEnv* env = AttachCurrentThread();
+  WebResourceRequest web_request(env, request);
 
   vector<string> response_header_names;
   vector<string> response_header_values;
   {
     void* headers_iterator = NULL;
     string header_name, header_value;
     while (response_headers->EnumerateHeaderLines(
         &headers_iterator, &header_name, &header_value)) {
       response_header_names.push_back(header_name);
       response_header_values.push_back(header_value);
     }
   }
 
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jstring> jstring_url =
-      ConvertUTF8ToJavaString(env, request->url().spec());
-  ScopedJavaLocalRef<jstring> jstring_method =
-      ConvertUTF8ToJavaString(env, request->method());
-  ScopedJavaLocalRef<jobjectArray> jstringArray_request_header_names =
-      ToJavaArrayOfStrings(env, request_header_names);
-  ScopedJavaLocalRef<jobjectArray> jstringArray_request_header_values =
-      ToJavaArrayOfStrings(env, request_header_values);
-
-  const content::ResourceRequestInfo* info =
-      content::ResourceRequestInfo::ForRequest(request);
-  bool is_main_frame = info &&
-      info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME;
-  bool has_user_gesture = info && info->HasUserGesture();
-
   string mime_type, encoding;
   response_headers->GetMimeTypeAndCharset(&mime_type, &encoding);
   ScopedJavaLocalRef<jstring> jstring_mime_type =
       ConvertUTF8ToJavaString(env, mime_type);
   ScopedJavaLocalRef<jstring> jstring_encoding =
       ConvertUTF8ToJavaString(env, encoding);
   int status_code = response_headers->response_code();
   ScopedJavaLocalRef<jstring> jstring_reason =
       ConvertUTF8ToJavaString(env, response_headers->GetStatusText());
   ScopedJavaLocalRef<jobjectArray> jstringArray_response_header_names =
       ToJavaArrayOfStrings(env, response_header_names);
   ScopedJavaLocalRef<jobjectArray> jstringArray_response_header_values =
       ToJavaArrayOfStrings(env, response_header_values);
 
   Java_AwContentsIoThreadClient_onReceivedHttpError(
       env,
       java_object_.obj(),
-      jstring_url.obj(),
-      is_main_frame,
-      has_user_gesture,
-      jstring_method.obj(),
-      jstringArray_request_header_names.obj(),
-      jstringArray_request_header_values.obj(),
+      web_request.jstring_url.obj(),
+      web_request.is_main_frame,
+      web_request.has_user_gesture,
+      web_request.jstring_method.obj(),
+      web_request.jstringArray_header_names.obj(),
+      web_request.jstringArray_header_values.obj(),
       jstring_mime_type.obj(),
       jstring_encoding.obj(),
       status_code,
       jstring_reason.obj(),
       jstringArray_response_header_names.obj(),
       jstringArray_response_header_values.obj());
 }
 
 bool RegisterAwContentsIoThreadClientImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 } // namespace android_webview