android_webview/browser/net/android_stream_reader_url_request_job.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "android_webview/browser/net/android_stream_reader_url_request_job.h"
   6
   7 #include <string>
   8
   9 #include "android_webview/browser/input_stream.h"
  10 #include "android_webview/browser/net/input_stream_reader.h"
  11 #include "base/android/jni_android.h"
  12 #include "base/android/jni_string.h"
  13 #include "base/bind.h"
  14 #include "base/bind_helpers.h"
  15 #include "base/lazy_instance.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/message_loop/message_loop_proxy.h"
  18 #include "base/strings/string_number_conversions.h"
  19 #include "base/task_runner.h"
  20 #include "base/threading/sequenced_worker_pool.h"
  21 #include "base/threading/thread.h"
  22 #include "content/public/browser/browser_thread.h"
  23 #include "net/base/io_buffer.h"
  24 #include "net/base/mime_util.h"
  25 #include "net/base/net_errors.h"
  26 #include "net/base/net_util.h"
  27 #include "net/http/http_response_headers.h"
  28 #include "net/http/http_response_info.h"
  29 #include "net/http/http_util.h"
  30 #include "net/url_request/url_request.h"
  31 #include "net/url_request/url_request_job_manager.h"
  32
  33 using android_webview::InputStream;
  34 using android_webview::InputStreamReader;
  35 using base::android::AttachCurrentThread;
  36 using base::PostTaskAndReplyWithResult;
  37 using content::BrowserThread;
  38
  39 namespace {
  40
  41 const int kHTTPOk = 200;
  42 const int kHTTPNotFound = 404;
  43
  44 const char kResponseHeaderViaShouldInterceptRequest[] =
  45     "Client-Via: shouldInterceptRequest";
  46 const char kHTTPOkText[] = "OK";
  47 const char kHTTPNotFoundText[] = "Not Found";
  48
  49 } // namespace
  50
  51 // The requests posted to the worker thread might outlive the job.  Thread-safe
  52 // ref counting is used to ensure that the InputStream and InputStreamReader
  53 // members of this class are still there when the closure is run on the worker
  54 // thread.
  55 class InputStreamReaderWrapper :
  56     public base::RefCountedThreadSafe<InputStreamReaderWrapper> {
  57  public:
  58   InputStreamReaderWrapper(
  59       scoped_ptr<InputStream> input_stream,
  60       scoped_ptr<InputStreamReader> input_stream_reader)
  61       : input_stream_(input_stream.Pass()),
  62         input_stream_reader_(input_stream_reader.Pass()) {
  63     DCHECK(input_stream_);
  64     DCHECK(input_stream_reader_);
  65   }
  66
  67   android_webview::InputStream* input_stream() {
  68     return input_stream_.get();
  69   }
  70
  71   int Seek(const net::HttpByteRange& byte_range) {
  72     return input_stream_reader_->Seek(byte_range);
  73   }
  74
  75   int ReadRawData(net::IOBuffer* buffer, int buffer_size) {
  76     return input_stream_reader_->ReadRawData(buffer, buffer_size);
  77   }
  78
  79  private:
  80   friend class base::RefCountedThreadSafe<InputStreamReaderWrapper>;
  81   ~InputStreamReaderWrapper() {}
  82
  83   scoped_ptr<android_webview::InputStream> input_stream_;
  84   scoped_ptr<android_webview::InputStreamReader> input_stream_reader_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(InputStreamReaderWrapper);
  87 };
  88
  89 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
  90     net::URLRequest* request,
  91     net::NetworkDelegate* network_delegate,
  92     scoped_ptr<Delegate> delegate)
  93     : URLRequestJob(request, network_delegate),
  94       delegate_(delegate.Pass()),
  95       weak_factory_(this) {
  96   DCHECK(delegate_);
  97 }
  98
  99 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() {
 100 }
 101
 102 namespace {
 103
 104 typedef base::Callback<
 105     void(scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>,
 106          scoped_ptr<InputStream>)> OnInputStreamOpenedCallback;
 107
 108 // static
 109 void OpenInputStreamOnWorkerThread(
 110     scoped_refptr<base::MessageLoopProxy> job_thread_proxy,
 111     scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate> delegate,
 112     const GURL& url,
 113     OnInputStreamOpenedCallback callback) {
 114
 115   JNIEnv* env = AttachCurrentThread();
 116   DCHECK(env);
 117
 118   scoped_ptr<InputStream> input_stream = delegate->OpenInputStream(env, url);
 119   job_thread_proxy->PostTask(FROM_HERE,
 120                              base::Bind(callback,
 121                                         base::Passed(delegate.Pass()),
 122                                         base::Passed(input_stream.Pass())));
 123 }
 124
 125 } // namespace
 126
 127 void AndroidStreamReaderURLRequestJob::Start() {
 128   DCHECK(thread_checker_.CalledOnValidThread());
 129   // Start reading asynchronously so that all error reporting and data
 130   // callbacks happen as they would for network requests.
 131   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING,
 132                                   net::ERR_IO_PENDING));
 133
 134   // This could be done in the InputStreamReader but would force more
 135   // complex synchronization in the delegate.
 136   GetWorkerThreadRunner()->PostTask(
 137       FROM_HERE,
 138       base::Bind(
 139           &OpenInputStreamOnWorkerThread,
 140           base::MessageLoop::current()->message_loop_proxy(),
 141           // This is intentional - the job could be deleted while the callback
 142           // is executing on the background thread.
 143           // The delegate will be "returned" to the job once the InputStream
 144           // open attempt is completed.
 145           base::Passed(&delegate_),
 146           request()->url(),
 147           base::Bind(&AndroidStreamReaderURLRequestJob::OnInputStreamOpened,
 148                      weak_factory_.GetWeakPtr())));
 149 }
 150
 151 void AndroidStreamReaderURLRequestJob::Kill() {
 152   DCHECK(thread_checker_.CalledOnValidThread());
 153   weak_factory_.InvalidateWeakPtrs();
 154   URLRequestJob::Kill();
 155 }
 156
 157 scoped_ptr<InputStreamReader>
 158 AndroidStreamReaderURLRequestJob::CreateStreamReader(InputStream* stream) {
 159   return make_scoped_ptr(new InputStreamReader(stream));
 160 }
 161
 162 void AndroidStreamReaderURLRequestJob::OnInputStreamOpened(
 163       scoped_ptr<Delegate> returned_delegate,
 164       scoped_ptr<android_webview::InputStream> input_stream) {
 165   DCHECK(thread_checker_.CalledOnValidThread());
 166   DCHECK(returned_delegate);
 167   delegate_ = returned_delegate.Pass();
 168
 169   if (!input_stream) {
 170     bool restart_required = false;
 171     delegate_->OnInputStreamOpenFailed(request(), &restart_required);
 172     if (restart_required) {
 173       NotifyRestartRequired();
 174     } else {
 175       // Clear the IO_PENDING status set in Start().
 176       SetStatus(net::URLRequestStatus());
 177       HeadersComplete(kHTTPNotFound, kHTTPNotFoundText);
 178     }
 179     return;
 180   }
 181
 182   scoped_ptr<InputStreamReader> input_stream_reader(
 183       CreateStreamReader(input_stream.get()));
 184   DCHECK(input_stream_reader);
 185
 186   DCHECK(!input_stream_reader_wrapper_.get());
 187   input_stream_reader_wrapper_ = new InputStreamReaderWrapper(
 188       input_stream.Pass(), input_stream_reader.Pass());
 189
 190   PostTaskAndReplyWithResult(
 191       GetWorkerThreadRunner(),
 192       FROM_HERE,
 193       base::Bind(&InputStreamReaderWrapper::Seek,
 194                  input_stream_reader_wrapper_,
 195                  byte_range_),
 196       base::Bind(&AndroidStreamReaderURLRequestJob::OnReaderSeekCompleted,
 197                  weak_factory_.GetWeakPtr()));
 198 }
 199
 200 void AndroidStreamReaderURLRequestJob::OnReaderSeekCompleted(int result) {
 201   DCHECK(thread_checker_.CalledOnValidThread());
 202   // Clear the IO_PENDING status set in Start().
 203   SetStatus(net::URLRequestStatus());
 204   if (result >= 0) {
 205     set_expected_content_size(result);
 206     HeadersComplete(kHTTPOk, kHTTPOkText);
 207   } else {
 208     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
 209   }
 210 }
 211
 212 void AndroidStreamReaderURLRequestJob::OnReaderReadCompleted(int result) {
 213   DCHECK(thread_checker_.CalledOnValidThread());
 214   // The URLRequest API contract requires that:
 215   // * NotifyDone be called once, to set the status code, indicate the job is
 216   //   finished (there will be no further IO),
 217   // * NotifyReadComplete be called if false is returned from ReadRawData to
 218   //   indicate that the IOBuffer will not be used by the job anymore.
 219   // There might be multiple calls to ReadRawData (and thus multiple calls to
 220   // NotifyReadComplete), which is why NotifyDone is called only on errors
 221   // (result < 0) and end of data (result == 0).
 222   if (result == 0) {
 223     NotifyDone(net::URLRequestStatus());
 224   } else if (result < 0) {
 225     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
 226   } else {
 227     // Clear the IO_PENDING status.
 228     SetStatus(net::URLRequestStatus());
 229   }
 230   NotifyReadComplete(result);
 231 }
 232
 233 base::TaskRunner* AndroidStreamReaderURLRequestJob::GetWorkerThreadRunner() {
 234   return static_cast<base::TaskRunner*>(BrowserThread::GetBlockingPool());
 235 }
 236
 237 bool AndroidStreamReaderURLRequestJob::ReadRawData(net::IOBuffer* dest,
 238                                                    int dest_size,
 239                                                    int* bytes_read) {
 240   DCHECK(thread_checker_.CalledOnValidThread());
 241   if (!input_stream_reader_wrapper_.get()) {
 242     // This will happen if opening the InputStream fails in which case the
 243     // error is communicated by setting the HTTP response status header rather
 244     // than failing the request during the header fetch phase.
 245     *bytes_read = 0;
 246     return true;
 247   }
 248
 249   PostTaskAndReplyWithResult(
 250       GetWorkerThreadRunner(),
 251       FROM_HERE,
 252       base::Bind(&InputStreamReaderWrapper::ReadRawData,
 253                  input_stream_reader_wrapper_,
 254                  make_scoped_refptr(dest),
 255                  dest_size),
 256       base::Bind(&AndroidStreamReaderURLRequestJob::OnReaderReadCompleted,
 257                  weak_factory_.GetWeakPtr()));
 258
 259   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING,
 260                                   net::ERR_IO_PENDING));
 261   return false;
 262 }
 263
 264 bool AndroidStreamReaderURLRequestJob::GetMimeType(
 265     std::string* mime_type) const {
 266   DCHECK(thread_checker_.CalledOnValidThread());
 267   JNIEnv* env = AttachCurrentThread();
 268   DCHECK(env);
 269
 270   if (!input_stream_reader_wrapper_.get())
 271     return false;
 272
 273   // Since it's possible for this call to alter the InputStream a
 274   // Seek or ReadRawData operation running in the background is not permitted.
 275   DCHECK(!request_->status().is_io_pending());
 276
 277   return delegate_->GetMimeType(
 278       env, request(), input_stream_reader_wrapper_->input_stream(), mime_type);
 279 }
 280
 281 bool AndroidStreamReaderURLRequestJob::GetCharset(std::string* charset) {
 282   DCHECK(thread_checker_.CalledOnValidThread());
 283   JNIEnv* env = AttachCurrentThread();
 284   DCHECK(env);
 285
 286   if (!input_stream_reader_wrapper_.get())
 287     return false;
 288
 289   // Since it's possible for this call to alter the InputStream a
 290   // Seek or ReadRawData operation running in the background is not permitted.
 291   DCHECK(!request_->status().is_io_pending());
 292
 293   return delegate_->GetCharset(
 294       env, request(), input_stream_reader_wrapper_->input_stream(), charset);
 295 }
 296
 297 void AndroidStreamReaderURLRequestJob::HeadersComplete(
 298     int status_code,
 299     const std::string& status_text) {
 300   std::string status("HTTP/1.1 ");
 301   status.append(base::IntToString(status_code));
 302   status.append(" ");
 303   status.append(status_text);
 304   // HttpResponseHeaders expects its input string to be terminated by two NULs.
 305   status.append("\0\0", 2);
 306   net::HttpResponseHeaders* headers = new net::HttpResponseHeaders(status);
 307
 308   if (status_code == kHTTPOk) {
 309     if (expected_content_size() != -1) {
 310       std::string content_length_header(
 311           net::HttpRequestHeaders::kContentLength);
 312       content_length_header.append(": ");
 313       content_length_header.append(
 314           base::Int64ToString(expected_content_size()));
 315       headers->AddHeader(content_length_header);
 316     }
 317
 318     std::string mime_type;
 319     if (GetMimeType(&mime_type) && !mime_type.empty()) {
 320       std::string content_type_header(net::HttpRequestHeaders::kContentType);
 321       content_type_header.append(": ");
 322       content_type_header.append(mime_type);
 323       headers->AddHeader(content_type_header);
 324     }
 325   }
 326
 327   JNIEnv* env = AttachCurrentThread();
 328   DCHECK(env);
 329   delegate_->AppendResponseHeaders(env, headers);
 330
 331   // Indicate that the response had been obtained via shouldInterceptRequest.
 332   headers->AddHeader(kResponseHeaderViaShouldInterceptRequest);
 333
 334   response_info_.reset(new net::HttpResponseInfo());
 335   response_info_->headers = headers;
 336
 337   NotifyHeadersComplete();
 338 }
 339
 340 int AndroidStreamReaderURLRequestJob::GetResponseCode() const {
 341   if (response_info_)
 342     return response_info_->headers->response_code();
 343   return URLRequestJob::GetResponseCode();
 344 }
 345
 346 void AndroidStreamReaderURLRequestJob::GetResponseInfo(
 347     net::HttpResponseInfo* info) {
 348   if (response_info_)
 349     *info = *response_info_;
 350 }
 351
 352 void AndroidStreamReaderURLRequestJob::SetExtraRequestHeaders(
 353     const net::HttpRequestHeaders& headers) {
 354   std::string range_header;
 355   if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
 356     // We only extract the "Range" header so that we know how many bytes in the
 357     // stream to skip and how many to read after that.
 358     std::vector<net::HttpByteRange> ranges;
 359     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
 360       if (ranges.size() == 1) {
 361         byte_range_ = ranges[0];
 362       } else {
 363         // We don't support multiple range requests in one single URL request,
 364         // because we need to do multipart encoding here.
 365         NotifyDone(net::URLRequestStatus(
 366             net::URLRequestStatus::FAILED,
 367             net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
 368       }
 369     }
 370   }
 371 }