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(
-    WebResourceRequest web_request,
+    const AwWebResourceRequest& 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;
 
-  web_request.ConvertToJava(env);
+  AwWebResourceRequest::AwJavaWebResourceRequest java_web_resource_request;
+  AwWebResourceRequest::ConvertToJava(env, request, &java_web_resource_request);
 
   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
       "shouldInterceptRequest");
   ScopedJavaLocalRef<jobject> ret =
       AwContentsBackgroundThreadClient::shouldInterceptRequest(
-          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);
+          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);
   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, WebResourceRequest(request),
+        &RunShouldInterceptRequest, AwWebResourceRequest(*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