Revert of Move onReceivedError and onReceivedHttpError out of AwContentsIoThreadClientImpl

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 <memory>
 #include <utility>
 
-#include "android_webview/browser/net/aw_web_resource_request.h"
 #include "android_webview/common/devtools_instrumentation.h"
 #include "android_webview/native/aw_contents_background_thread_client.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/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;
 using base::LazyInstance;
 using content::BrowserThread;
 using content::RenderFrameHost;
 using content::ResourceType;
 using content::WebContents;
 using std::map;
 using std::pair;
 using std::string;
+using std::vector;
 
 namespace android_webview {
 
 namespace {
 
 struct IoThreadClientData {
   bool pending_association;
   JavaObjectWeakGlobalRef io_thread_client;
 
   IoThreadClientData();
@@ skipping 94 matching lines @@
 }
 
 void ClientMapEntryUpdater::RenderFrameDeleted(RenderFrameHost* rfh) {
   RfhToIoThreadClientMap::GetInstance()->Erase(GetRenderFrameHostIdPair(rfh));
 }
 
 void ClientMapEntryUpdater::WebContentsDestroyed() {
   delete this;
 }
 
+struct WebResourceRequest {
+  std::string url;
+  std::string method;
+  bool is_main_frame;
+  bool has_user_gesture;
+  vector<string> header_names;
+  vector<string> header_values;
+
+  ScopedJavaLocalRef<jstring> jstring_url;
+  ScopedJavaLocalRef<jstring> jstring_method;
+  ScopedJavaLocalRef<jobjectArray> jstringArray_header_names;
+  ScopedJavaLocalRef<jobjectArray> jstringArray_header_values;
+
+  WebResourceRequest(const net::URLRequest* request)
+      : url(request->url().spec()),
+        method(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();
+
+    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());
+    }
+  }
+
+  WebResourceRequest(JNIEnv* env, const net::URLRequest* request)
+      : WebResourceRequest(request) {
+    ConvertToJava(env);
+  }
+
+  void ConvertToJava(JNIEnv* env) {
+    jstring_url = ConvertUTF8ToJavaString(env, url);
+    jstring_method = ConvertUTF8ToJavaString(env, method);
+    jstringArray_header_names = ToJavaArrayOfStrings(env, header_names);
+    jstringArray_header_values = ToJavaArrayOfStrings(env, header_values);
+  }
+};
+
 } // namespace
 
 // AwContentsIoThreadClientImpl -----------------------------------------------
 
 // static
 std::unique_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;
@@ skipping 90 matching lines @@
 
   JNIEnv* env = AttachCurrentThread();
   return static_cast<AwContentsIoThreadClient::CacheMode>(
       Java_AwContentsIoThreadClient_getCacheMode(env, java_object_));
 }
 
 
 namespace {
 
 std::unique_ptr<AwWebResourceResponse> RunShouldInterceptRequest(
-    const AwWebResourceRequest& request,
+    WebResourceRequest web_request,
     JavaObjectWeakGlobalRef ref) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   JNIEnv* env = AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> obj = ref.get(env);
   if (obj.is_null())
     return nullptr;
 
-  AwWebResourceRequest::AwJavaWebResourceRequest java_web_resource_request;
-  AwWebResourceRequest::ConvertToJava(env, request, &java_web_resource_request);
+  web_request.ConvertToJava(env);
 
   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
       "shouldInterceptRequest");
   ScopedJavaLocalRef<jobject> ret =
       AwContentsBackgroundThreadClient::shouldInterceptRequest(
-          env, obj, java_web_resource_request.jurl, request.is_main_frame,
-          request.has_user_gesture, java_web_resource_request.jmethod,
-          java_web_resource_request.jheader_names,
-          java_web_resource_request.jheader_values);
+          env, obj, web_request.jstring_url, web_request.is_main_frame,
+          web_request.has_user_gesture, web_request.jstring_method,
+          web_request.jstringArray_header_names,
+          web_request.jstringArray_header_values);
   return std::unique_ptr<AwWebResourceResponse>(
       ret.is_null() ? nullptr : new AwWebResourceResponseImpl(ret));
 }
 
 std::unique_ptr<AwWebResourceResponse> ReturnNull() {
   return std::unique_ptr<AwWebResourceResponse>();
 }
 
 }  // namespace
 
 void AwContentsIoThreadClientImpl::ShouldInterceptRequestAsync(
     const net::URLRequest* request,
     const ShouldInterceptRequestResultCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   base::Callback<std::unique_ptr<AwWebResourceResponse>()> get_response =
       base::Bind(&ReturnNull);
   JNIEnv* env = AttachCurrentThread();
   if (bg_thread_client_object_.is_null() && !java_object_.is_null()) {
     bg_thread_client_object_.Reset(
         Java_AwContentsIoThreadClient_getBackgroundThreadClient(env,
                                                                 java_object_));
   }
   if (!bg_thread_client_object_.is_null()) {
     get_response = base::Bind(
-        &RunShouldInterceptRequest, AwWebResourceRequest(*request),
+        &RunShouldInterceptRequest, WebResourceRequest(request),
         JavaObjectWeakGlobalRef(env, bg_thread_client_object_.obj()));
   }
   BrowserThread::PostTaskAndReplyWithResult(BrowserThread::FILE, FROM_HERE,
                                             get_response, callback);
 }
 
 bool AwContentsIoThreadClientImpl::ShouldBlockContentUrls() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
@@ skipping 25 matching lines @@
 bool AwContentsIoThreadClientImpl::ShouldBlockNetworkLoads() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_shouldBlockNetworkLoads(env,
                                                                java_object_);
 }
 
+void AwContentsIoThreadClientImpl::OnReceivedError(
+    const net::URLRequest* request) {
+  DCHECK_CURRENTLY_ON(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_, web_request.jstring_url, web_request.is_main_frame,
+      web_request.has_user_gesture, web_request.jstring_method,
+      web_request.jstringArray_header_names,
+      web_request.jstringArray_header_values, error_code, jstring_description);
+}
+
+void AwContentsIoThreadClientImpl::OnReceivedHttpError(
+    const net::URLRequest* request,
+    const net::HttpResponseHeaders* response_headers) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (java_object_.is_null())
+    return;
+
+  JNIEnv* env = AttachCurrentThread();
+  WebResourceRequest web_request(env, request);
+
+  vector<string> response_header_names;
+  vector<string> response_header_values;
+  {
+    size_t headers_iterator = 0;
+    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);
+    }
+  }
+
+  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_, web_request.jstring_url, web_request.is_main_frame,
+      web_request.has_user_gesture, web_request.jstring_method,
+      web_request.jstringArray_header_names,
+      web_request.jstringArray_header_values, jstring_mime_type,
+      jstring_encoding, status_code, jstring_reason,
+      jstringArray_response_header_names, jstringArray_response_header_values);
+}
+
 } // namespace android_webview