[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 77 matching lines @@
 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(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    scoped_ptr<DelegateObtainer> delegate_obtainer,
+    bool)
+    : URLRequestJob(request, network_delegate),
+      delegate_obtainer_(delegate_obtainer.Pass()),
+      weak_factory_(this) {
+  DCHECK(delegate_obtainer_);
+}
+
 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() {
 }
 
 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() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // 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())));
+  if (!delegate_) {
+    DCHECK(delegate_obtainer_);
+    delegate_obtainer_->ObtainDelegate(
+        request(),
+        base::Bind(&AndroidStreamReaderURLRequestJob::DelegateObtained,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    DoStart();
+  }
 }
 
 void AndroidStreamReaderURLRequestJob::Kill() {
   DCHECK(thread_checker_.CalledOnValidThread());
   weak_factory_.InvalidateWeakPtrs();
   URLRequestJob::Kill();
 }
 
 scoped_ptr<InputStreamReader>
 AndroidStreamReaderURLRequestJob::CreateStreamReader(InputStream* stream) {
@@ skipping 128 matching lines @@
     return false;
 
   // Since it's possible for this call to alter the InputStream a
   // Seek or ReadRawData operation running in the background is not permitted.
   DCHECK(!request_->status().is_io_pending());
 
   return delegate_->GetCharset(
       env, request(), input_stream_reader_wrapper_->input_stream(), charset);
 }
 
+void AndroidStreamReaderURLRequestJob::DelegateObtained(
+    scoped_ptr<Delegate> delegate) {
+  DCHECK(!delegate_);
+  delegate_obtainer_.reset(nullptr);

[boliu, 2015/10/01 19:13:56]

nit: just reset()

[mnaganov (inactive), 2015/10/01 19:51:03]

Done.

+  if (delegate) {
+    delegate_.swap(delegate);

[boliu, 2015/10/01 19:13:56]

DCHECK(!delegate_) before swap? I think that's correct..?

[mnaganov (inactive), 2015/10/01 19:51:03]

Look three lines above :)

+    DoStart();
+  } else {
+    NotifyRestartRequired();
+  }
+}
+
+void AndroidStreamReaderURLRequestJob::DoStart() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // 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::HeadersComplete(
     int status_code,
     const std::string& status_text) {
   std::string status("HTTP/1.1 ");
   status.append(base::IntToString(status_code));
   status.append(" ");
   status.append(status_text);
   // HttpResponseHeaders expects its input string to be terminated by two NULs.
   status.append("\0\0", 2);
   net::HttpResponseHeaders* headers = new net::HttpResponseHeaders(status);
@@ skipping 57 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