[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/input_stream_reader.h"
@@ skipping 69 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),
+      weak_factory_(this) {
+}
+
+AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
+    net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     scoped_ptr<Delegate> delegate)
     : URLRequestJob(request, network_delegate),
       delegate_(delegate.Pass()),
       weak_factory_(this) {
   DCHECK(delegate_);
 }
 
 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() {
 }
 
+void AndroidStreamReaderURLRequestJob::DeliverResponseFromDelegate(
+    scoped_ptr<Delegate> delegate) {
+  DCHECK(!delegate_);
+  delegate_ = delegate.Pass();
+  DCHECK(delegate_);
+  MaybeStart();

[boliu, 2015/09/28 23:26:28]

Does this need to check that Start has indeed been called already? We don't want
to start the request ourselves, right?

[mnaganov (inactive), 2015/09/29 00:14:06]

Good point! Also we don't want to start if we have already been killed :)

+}
+
+void AndroidStreamReaderURLRequestJob::DeliverResponseFromNetwork() {
+  DCHECK(!delegate_);
+  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 (!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() {
+  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