[android_webview] Make intercepted URLRequests have status codes.

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"
 #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/message_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_manager.h"
 
 using android_webview::InputStream;
 using android_webview::InputStreamReader;
 using base::android::AttachCurrentThread;
 using base::PostTaskAndReplyWithResult;
 using content::BrowserThread;
 
+namespace {
+
+const int kHTTPOk = 200;

[benm (inactive), 2013/03/06 17:05:11]

these surely must be defined somewhere in chromium already?

[mkosiba (inactive), 2013/03/07 18:52:01]

yeath.. somewhere in uh.. drive_url_request_job. I don't think this is enough
duplication that creating a separate component / spending the effort to add this
to the content/ layer is worth it.

+const int kHTTPNotFound = 404;
+
+const char kHTTPOkText[] = "OK";
+const char kHTTPNotFoundText[] = "Not Found";
+
+} // namespace
+
 // The requests posted to the worker thread might outlive the job.  Thread-safe
 // ref counting is used to ensure that the InputStream and InputStreamReader
 // members of this class are still there when the closure is run on the worker
 // thread.
 class InputStreamReaderWrapper :
     public base::RefCountedThreadSafe<InputStreamReaderWrapper> {
  public:
   InputStreamReaderWrapper(
       scoped_ptr<InputStream> input_stream,
       scoped_ptr<InputStreamReader> input_stream_reader)
@@ skipping 63 matching lines @@
 void AndroidStreamReaderURLRequestJob::StartAsync() {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
 
   // This could be done in the InputStreamReader but would force more
   // complex synchronization in the delegate.
   scoped_ptr<android_webview::InputStream> stream(
       delegate_->OpenInputStream(env, request()));
 
   if (!stream) {
-    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                     net::ERR_FAILED));
+    // Clear the IO_PENDING status set in Start().
+    SetStatus(net::URLRequestStatus());
+    HeadersComplete(kHTTPNotFound, kHTTPNotFoundText);
     return;
   }
 
   scoped_ptr<InputStreamReader> input_stream_reader(
       CreateStreamReader(stream.get()));
   DCHECK(input_stream_reader);
 
   DCHECK(!input_stream_reader_wrapper_);
   input_stream_reader_wrapper_ =
       new InputStreamReaderWrapper(stream.Pass(), input_stream_reader.Pass());
 
   PostTaskAndReplyWithResult(
       GetWorkerThreadRunner(),
       FROM_HERE,
       base::Bind(&InputStreamReaderWrapper::Seek,
                  input_stream_reader_wrapper_,
                  byte_range_),
       base::Bind(&AndroidStreamReaderURLRequestJob::OnReaderSeekCompleted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AndroidStreamReaderURLRequestJob::OnReaderSeekCompleted(int result) {
   // Clear the IO_PENDING status set in Start().
   SetStatus(net::URLRequestStatus());
   if (result >= 0) {
     set_expected_content_size(result);
-    NotifyHeadersComplete();
+    HeadersComplete(kHTTPOk, kHTTPOkText);
   } else {
     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
   }
 }
 
 void AndroidStreamReaderURLRequestJob::OnReaderReadCompleted(int result) {
   // The URLRequest API contract requires that:
   // * NotifyDone be called once, to set the status code, indicate the job is
   //   finished (there will be no further IO),
   // * NotifyReadComplete be called if false is returned from ReadRawData to
@@ skipping 12 matching lines @@
   NotifyReadComplete(result);
 }
 
 base::TaskRunner* AndroidStreamReaderURLRequestJob::GetWorkerThreadRunner() {
   return static_cast<base::TaskRunner*>(BrowserThread::GetBlockingPool());
 }
 
 bool AndroidStreamReaderURLRequestJob::ReadRawData(net::IOBuffer* dest,
                                                    int dest_size,
                                                    int* bytes_read) {
-  DCHECK(input_stream_reader_wrapper_);
+  if (!input_stream_reader_wrapper_) {
+    // This will happen if opening the InputStream fails in which case the
+    // error is communicated by setting the HTTP response status header rather
+    // than failing the entire request.
+    *bytes_read = 0;
+    return true;
+  }
 
   PostTaskAndReplyWithResult(
       GetWorkerThreadRunner(),
       FROM_HERE,
       base::Bind(&InputStreamReaderWrapper::ReadRawData,
                  input_stream_reader_wrapper_,
                  make_scoped_refptr(dest),
                  dest_size),
       base::Bind(&AndroidStreamReaderURLRequestJob::OnReaderReadCompleted,
                  weak_factory_.GetWeakPtr()));
@@ skipping 27 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::HeadersComplete(
+    int status_code,

[mnaganov (inactive), 2013/03/06 13:33:10]

nit: please move the first arg in line with the function name

[mkosiba (inactive), 2013/03/07 18:52:01]

No can do. The chromium style guide says that you need to do either:

  // 1)
  void class::f(a,b,c)
  // 2)
  void class::f(a,
                b,
                c)
  // 3)
  void class:f(
      a,
      b,
      c)

In my case 2) is not possible since the second line would be longer than the
line limit, so have to stick with 3)

[mnaganov (inactive), 2013/03/08 09:15:47]

Ah, sorry. The second line visually looks as if it should fit, but perhaps it's
just longer by 1 char.

+    const std::string& status_text) {
+  std::string status("HTTP/1.1 ");

[benm (inactive), 2013/03/06 17:05:11]

It feels weird to me we need to do this from scratch.. no helpers int net/ or
something?

[mkosiba (inactive), 2013/03/07 18:52:01]

nope, I did spend a while searching. The Chromium net stack doesn't really care
about http headers, to it the headers are just data. Even the http job treats
them in a rather generic way.

+  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);
+
+  if (status_code == kHTTPOk) {
+    if (expected_content_size() != -1) {
+      std::string content_length_header(
+          net::HttpRequestHeaders::kContentLength);
+      content_length_header.append(": ");
+      content_length_header.append(
+          base::Int64ToString(expected_content_size()));

[mnaganov (inactive), 2013/03/06 13:33:10]

nit: is this wrap needed?

[mkosiba (inactive), 2013/03/07 18:52:01]

yes. If I join the lines they don't fit in the line length limit.

[mnaganov (inactive), 2013/03/08 09:15:47]

Ah, it's Rietveld fooling me--it displays a lot of whitespace on the right, so
visually it looks like as if it would fit. Sorry for giving wrong suggestions!

+      headers->AddHeader(content_length_header);
+    }
+
+    std::string mime_type;
+    if (GetMimeType(&mime_type) && !mime_type.empty()) {
+      std::string content_type_header(net::HttpRequestHeaders::kContentType);
+      content_type_header.append(": ");
+      content_type_header.append(mime_type);
+      headers->AddHeader(content_type_header);
+    }
+  }
+
+  response_info_.reset(new net::HttpResponseInfo());
+  response_info_->headers = headers;
+
+  NotifyHeadersComplete();
+}
+
+int AndroidStreamReaderURLRequestJob::GetResponseCode() const {
+  if (response_info_)
+    return response_info_->headers->response_code();
+  return URLRequestJob::GetResponseCode();
+}
+
+void AndroidStreamReaderURLRequestJob::GetResponseInfo(
+    net::HttpResponseInfo* info) {
+  if (response_info_)
+    *info = *response_info_;
+}
+
 void AndroidStreamReaderURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
   std::string range_header;
   if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
     // We only extract the "Range" header so that we know how many bytes in the
     // stream to skip and how many to read after that.
     std::vector<net::HttpByteRange> ranges;
     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
       if (ranges.size() == 1) {
         byte_range_ = ranges[0];
       } else {
         // We don't support multiple range requests in one single URL request,
         // because we need to do multipart encoding here.
         NotifyDone(net::URLRequestStatus(
             net::URLRequestStatus::FAILED,
             net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
       }
     }
   }
 }