[WebView] Replace AwContentsIoThreadClient, InputStream and AwWebResourceResponse

android_webview/browser/aw_contents_io_thread_client.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/browser/aw_contents_io_thread_client_impl.h"
+#include "android_webview/browser/aw_contents_io_thread_client.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "android_webview/browser/aw_contents_background_thread_client.h"
-#include "android_webview/browser/aw_web_resource_response_impl.h"
 #include "android_webview/browser/net/aw_web_resource_request.h"
+#include "android_webview/browser/net/aw_web_resource_response.h"
 #include "android_webview/common/devtools_instrumentation.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"
@@ skipping 160 matching lines @@
   RfhToIoThreadClientMap::GetInstance()->Erase(GetRenderFrameHostIdPair(rfh));
   RfhToIoThreadClientMap::GetInstance()->Erase(rfh->GetFrameTreeNodeId());
 }
 
 void ClientMapEntryUpdater::WebContentsDestroyed() {
   delete this;
 }
 
 }  // namespace
 
-// AwContentsIoThreadClientImpl -----------------------------------------------
+// AwContentsIoThreadClient -----------------------------------------------
 
 // 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;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(rfh_id, &client_data))
     return std::unique_ptr<AwContentsIoThreadClient>();
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> java_delegate =
       client_data.io_thread_client.get(env);
   DCHECK(!client_data.pending_association || java_delegate.is_null());
-  return std::unique_ptr<AwContentsIoThreadClient>(
-      new AwContentsIoThreadClientImpl(client_data.pending_association,
-                                       java_delegate));
+  return std::unique_ptr<AwContentsIoThreadClient>(new AwContentsIoThreadClient(
+      client_data.pending_association, java_delegate));
 }
 
 std::unique_ptr<AwContentsIoThreadClient> AwContentsIoThreadClient::FromID(
     int frame_tree_node_id) {
   IoThreadClientData client_data;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(frame_tree_node_id,
                                                   &client_data))
     return std::unique_ptr<AwContentsIoThreadClient>();
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> java_delegate =
       client_data.io_thread_client.get(env);
   DCHECK(!client_data.pending_association || java_delegate.is_null());
-  return std::unique_ptr<AwContentsIoThreadClient>(
-      new AwContentsIoThreadClientImpl(client_data.pending_association,
-                                       java_delegate));
+  return std::unique_ptr<AwContentsIoThreadClient>(new AwContentsIoThreadClient(
+      client_data.pending_association, java_delegate));
 }
 
 // static
 void AwContentsIoThreadClient::SubFrameCreated(int render_process_id,
                                                int parent_render_frame_id,
                                                int child_render_frame_id) {
   pair<int, int> parent_rfh_id(render_process_id, parent_render_frame_id);
   pair<int, int> child_rfh_id(render_process_id, child_render_frame_id);
   IoThreadClientData client_data;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(parent_rfh_id,
                                                   &client_data)) {
     NOTREACHED();
     return;
   }
 
   RfhToIoThreadClientMap::GetInstance()->Set(child_rfh_id, client_data);
 }
 
 // static
-void AwContentsIoThreadClientImpl::RegisterPendingContents(
+void AwContentsIoThreadClient::RegisterPendingContents(
     WebContents* web_contents) {
   IoThreadClientData client_data;
   client_data.pending_association = true;
   RfhToIoThreadClientMap::GetInstance()->Set(
       GetRenderFrameHostIdPair(web_contents->GetMainFrame()), client_data);
 }
 
 // static
-void AwContentsIoThreadClientImpl::Associate(WebContents* web_contents,
-                                             const JavaRef<jobject>& jclient) {
+void AwContentsIoThreadClient::Associate(WebContents* web_contents,
+                                         const JavaRef<jobject>& jclient) {
   JNIEnv* env = AttachCurrentThread();
   // The ClientMapEntryUpdater lifespan is tied to the WebContents.
   new ClientMapEntryUpdater(env, web_contents, jclient.obj());
 }
 
 // static
-void AwContentsIoThreadClientImpl::SetServiceWorkerIoThreadClient(
+void AwContentsIoThreadClient::SetServiceWorkerIoThreadClient(
     const base::android::JavaRef<jobject>& jclient,
     const base::android::JavaRef<jobject>& browser_context) {
   // TODO: currently there is only one browser context so it is ok to
   // store in a global variable, in the future use browser_context to
   // obtain the correct instance.
   JavaObjectWeakGlobalRef temp(AttachCurrentThread(), jclient.obj());
   g_sw_instance_.Get() = temp;
 }
 
 // static
 std::unique_ptr<AwContentsIoThreadClient>
 AwContentsIoThreadClient::GetServiceWorkerIoThreadClient() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> java_delegate = g_sw_instance_.Get().get(env);
 
   if (java_delegate.is_null())
     return std::unique_ptr<AwContentsIoThreadClient>();
 
   return std::unique_ptr<AwContentsIoThreadClient>(
-      new AwContentsIoThreadClientImpl(false, java_delegate));
+      new AwContentsIoThreadClient(false, java_delegate));
 }
 
-AwContentsIoThreadClientImpl::AwContentsIoThreadClientImpl(
-    bool pending_association,
-    const JavaRef<jobject>& obj)
+AwContentsIoThreadClient::AwContentsIoThreadClient(bool pending_association,
+                                                   const JavaRef<jobject>& obj)
     : pending_association_(pending_association), java_object_(obj) {}
 
-AwContentsIoThreadClientImpl::~AwContentsIoThreadClientImpl() {
+AwContentsIoThreadClient::~AwContentsIoThreadClient() {
   // explict, out-of-line destructor.
 }
 
-bool AwContentsIoThreadClientImpl::PendingAssociation() const {
+bool AwContentsIoThreadClient::PendingAssociation() const {
   return pending_association_;
 }
 
-AwContentsIoThreadClient::CacheMode AwContentsIoThreadClientImpl::GetCacheMode()
+AwContentsIoThreadClient::CacheMode AwContentsIoThreadClient::GetCacheMode()
     const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return AwContentsIoThreadClient::LOAD_DEFAULT;
 
   JNIEnv* env = AttachCurrentThread();
   return static_cast<AwContentsIoThreadClient::CacheMode>(
       Java_AwContentsIoThreadClient_getCacheMode(env, java_object_));
 }
 
@@ skipping 13 matching lines @@
 
   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);
   return std::unique_ptr<AwWebResourceResponse>(
-      ret.is_null() ? nullptr : new AwWebResourceResponseImpl(ret));
+      ret.is_null() ? nullptr : new AwWebResourceResponse(ret));
 }
 
 std::unique_ptr<AwWebResourceResponse> ReturnNull() {
   return std::unique_ptr<AwWebResourceResponse>();
 }
 
 }  // namespace
 
-void AwContentsIoThreadClientImpl::ShouldInterceptRequestAsync(
+void AwContentsIoThreadClient::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),
         JavaObjectWeakGlobalRef(env, bg_thread_client_object_.obj()));
   }
   BrowserThread::PostTaskAndReplyWithResult(BrowserThread::FILE, FROM_HERE,
                                             get_response, callback);
 }
 
-bool AwContentsIoThreadClientImpl::ShouldBlockContentUrls() const {
+bool AwContentsIoThreadClient::ShouldBlockContentUrls() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_shouldBlockContentUrls(env,
                                                               java_object_);
 }
 
-bool AwContentsIoThreadClientImpl::ShouldBlockFileUrls() const {
+bool AwContentsIoThreadClient::ShouldBlockFileUrls() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_shouldBlockFileUrls(env, java_object_);
 }
 
-bool AwContentsIoThreadClientImpl::ShouldAcceptThirdPartyCookies() const {
+bool AwContentsIoThreadClient::ShouldAcceptThirdPartyCookies() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_shouldAcceptThirdPartyCookies(
       env, java_object_);
 }
 
-bool AwContentsIoThreadClientImpl::GetSafeBrowsingEnabled() const {
+bool AwContentsIoThreadClient::GetSafeBrowsingEnabled() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_getSafeBrowsingEnabled(env,
                                                               java_object_);
 }
 
-bool AwContentsIoThreadClientImpl::ShouldBlockNetworkLoads() const {
+bool AwContentsIoThreadClient::ShouldBlockNetworkLoads() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_shouldBlockNetworkLoads(env,
                                                                java_object_);
 }
 
 }  // namespace android_webview