[Android WebView] Call shouldInterceptRequest on a background thread

android_webview/browser/net/android_stream_reader_url_request_job.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/net/android_stream_reader_url_request_job.h"
 
 #include <string>
 
 #include "android_webview/browser/input_stream.h"
+#include "android_webview/browser/net/aw_stream_reader_job_delegate_impl.h"
 #include "android_webview/browser/net/input_stream_reader.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 60 matching lines @@
   ~InputStreamReaderWrapper() {}
 
   scoped_ptr<InputStream> input_stream_;
   scoped_ptr<InputStreamReader> input_stream_reader_;
 
   DISALLOW_COPY_AND_ASSIGN(InputStreamReaderWrapper);
 };
 
 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
     net::URLRequest* request,
+    net::NetworkDelegate* network_delegate)
+    : URLRequestJob(request, network_delegate),
+      has_been_started_(false),
+      weak_factory_(this) {
+}
+
+AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
+    net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     scoped_ptr<Delegate> delegate)
     : URLRequestJob(request, network_delegate),
       delegate_(delegate.Pass()),
+      has_been_started_(false),
       weak_factory_(this) {
   DCHECK(delegate_);
 }
 
 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() {
 }
 
+base::Callback<void(scoped_ptr<AwWebResourceResponse>)>
+AndroidStreamReaderURLRequestJob::GetWebResourceResponseCallback() {
+  return base::Bind(
+      &AndroidStreamReaderURLRequestJob::WebResourceResponseObtained,
+      weak_factory_.GetWeakPtr());
+}
+
+void AndroidStreamReaderURLRequestJob::WebResourceResponseObtained(
+    scoped_ptr<AwWebResourceResponse> response) {
+  DCHECK(!delegate_);
+  if (response) {
+    delegate_.reset(new AwStreamReaderJobDelegateImpl(response.Pass()));
+    MaybeStart();
+  } else {
+    NotifyRestartRequired();
+  }
+}
+
 namespace {
 
 typedef base::Callback<
     void(scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>,
          scoped_ptr<InputStream>)> OnInputStreamOpenedCallback;
 
 // static
 void OpenInputStreamOnWorkerThread(
     scoped_refptr<base::SingleThreadTaskRunner> job_thread_task_runner,
     scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate> delegate,
     const GURL& url,
     OnInputStreamOpenedCallback callback) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
 
   scoped_ptr<InputStream> input_stream = delegate->OpenInputStream(env, url);
   job_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(callback, base::Passed(delegate.Pass()),
                             base::Passed(input_stream.Pass())));
 }
 
 } // namespace
 
-void AndroidStreamReaderURLRequestJob::Start() {
+void AndroidStreamReaderURLRequestJob::MaybeStart() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (!has_been_started() || !delegate_)
+    return;
+
   // Start reading asynchronously so that all error reporting and data
   // callbacks happen as they would for network requests.
   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING,
                                   net::ERR_IO_PENDING));
 
   // This could be done in the InputStreamReader but would force more
   // complex synchronization in the delegate.
   GetWorkerThreadRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &OpenInputStreamOnWorkerThread,
           base::MessageLoop::current()->task_runner(),
           // This is intentional - the job could be deleted while the callback
           // is executing on the background thread.
           // The delegate will be "returned" to the job once the InputStream
           // open attempt is completed.
           base::Passed(&delegate_), request()->url(),
           base::Bind(&AndroidStreamReaderURLRequestJob::OnInputStreamOpened,
                      weak_factory_.GetWeakPtr())));
 }
 
+void AndroidStreamReaderURLRequestJob::Start() {
+  DCHECK(!has_been_started());
+  has_been_started_ = true;
+  MaybeStart();
+}
+
 void AndroidStreamReaderURLRequestJob::Kill() {
   DCHECK(thread_checker_.CalledOnValidThread());
   weak_factory_.InvalidateWeakPtrs();
   URLRequestJob::Kill();
 }
 
 scoped_ptr<InputStreamReader>
 AndroidStreamReaderURLRequestJob::CreateStreamReader(InputStream* stream) {
   return make_scoped_ptr(new InputStreamReader(stream));
 }
@@ skipping 203 matching lines @@
         // because we need to do multipart encoding here.
         NotifyDone(net::URLRequestStatus(
             net::URLRequestStatus::FAILED,
             net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
       }
     }
   }
 }
 
 }  // namespace android_webview