NavigationController prototype

webkit/browser/appcache/appcache_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 "webkit/browser/appcache/appcache_url_request_job.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_group.h"
 #include "webkit/browser/appcache/appcache_histograms.h"
 #include "webkit/browser/appcache/appcache_host.h"
 #include "webkit/browser/appcache/appcache_service.h"
+#include "webkit/browser/blob/blob_reader.h"
+#include "webkit/browser/blob/blob_storage_controller.h"
 
 namespace appcache {
 
+namespace {
+
+// Helper to make structs for synthesized responses
+net::HttpResponseInfo* MakeHttpResponseInfo(const std::string& raw_headers) {
+  net::HttpResponseInfo* info = new net::HttpResponseInfo;
+  info->request_time = base::Time::Now();
+  info->response_time = base::Time::Now();
+  info->was_cached = false;
+  info->headers = new net::HttpResponseHeaders(raw_headers);
+  std::string headers;
+  info->headers->GetNormalizedHeaders(&headers);
+  return info;
+}
+
+}
+
 AppCacheURLRequestJob::AppCacheURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     AppCacheStorage* storage,
     AppCacheHost* host)
     : net::URLRequestJob(request, network_delegate),
       host_(host),
       storage_(storage),
       has_been_started_(false), has_been_killed_(false),
       delivery_type_(AWAITING_DELIVERY_ORDERS),
       group_id_(0), cache_id_(kNoCacheId), is_fallback_(false),
       cache_entry_not_found_(false),
-      weak_factory_(this) {
+      weak_factory_(this),
+      is_main_resource_load_(false) {
   DCHECK(storage_);
 }
 
 void AppCacheURLRequestJob::DeliverAppCachedResponse(
     const GURL& manifest_url, int64 group_id, int64 cache_id,
     const AppCacheEntry& entry, bool is_fallback) {
   DCHECK(!has_delivery_orders());
   DCHECK(entry.has_response_id());
   delivery_type_ = APPCACHED_DELIVERY;
   manifest_url_ = manifest_url;
@@ skipping 63 matching lines @@
       AppCacheHistograms::AddAppCacheJobStartDelaySample(
           base::TimeTicks::Now() - start_time_tick_);
       request()->net_log().AddEvent(
           is_fallback_ ?
               net::NetLog::TYPE_APPCACHE_DELIVERING_FALLBACK_RESPONSE :
               net::NetLog::TYPE_APPCACHE_DELIVERING_CACHED_RESPONSE);
       storage_->LoadResponseInfo(
           manifest_url_, group_id_, entry_.response_id(), this);
       break;
 
+    case SYNTHESIZED_DELIVERY:
+      DCHECK(info_);
+      NotifyHeadersComplete();
+      break;
+
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AppCacheURLRequestJob::BeginExecutableHandlerDelivery() {
   DCHECK(CommandLine::ForCurrentProcess()->
             HasSwitch(kEnableExecutableHandlers));
-  if (!storage_->service()->handler_factory()) {
+  if (!storage_->service()->executable_handler_factory()) {
     BeginErrorDelivery("missing handler factory");
     return;
   }
 
+  if (is_range_request()) {
+    BeginErrorDelivery("sorry, no support for range requests yet");
+    return;
+  }
+
   request()->net_log().AddEvent(
       net::NetLog::TYPE_APPCACHE_DELIVERING_EXECUTABLE_RESPONSE);
 
   // We defer job delivery until the executable handler is spun up and
   // provides a response. The sequence goes like this...
   //
   // 1. First we load the cache.
   // 2. Then if the handler is not spun up, we load the script resource which
   //    is needed to spin it up.
   // 3. Then we ask then we ask the handler to compute a response.
   // 4. Finally we deilver that response to the caller.
   storage_->LoadCache(cache_id_, this);
 }
 
 void AppCacheURLRequestJob::OnCacheLoaded(AppCache* cache, int64 cache_id) {
   DCHECK_EQ(cache_id_, cache_id);
   DCHECK(!has_been_killed());
 
   if (!cache) {
     BeginErrorDelivery("cache load failed");
     return;
   }
 
   // Keep references to ensure they don't go out of scope until job completion.
   cache_ = cache;
   group_ = cache->owning_group();
 
+  // Detect odd ball cases where we want to return the resource instead of
+  // executing the script. If it's an exact match for the resource, just return it.
+  if (cache_->GetEntry(request()->url())) {
+    entry_.clear_types(AppCacheEntry::EXECUTABLE);
+    delivery_type_ = APPCACHED_DELIVERY;
+    BeginDelivery();
+    return;
+  }
   // If the handler is spun up, ask it to compute a response.
   AppCacheExecutableHandler* handler =
       cache->GetExecutableHandler(entry_.response_id());
   if (handler) {
     InvokeExecutableHandler(handler);
     return;
   }
 
   // Handler is not spun up yet, load the script resource to do that.
   // NOTE: This is not ideal since multiple jobs may be doing this,
@@ skipping 16 matching lines @@
 }
 
 void AppCacheURLRequestJob::OnExecutableSourceLoaded(int result) {
   DCHECK(!has_been_killed());
   handler_source_reader_.reset();
   if (result < 0) {
     BeginErrorDelivery("script source load failed");
     return;
   }
 
-  handler_source_buffer_->SetCapacity(result);  // Free up some memory.
+  std::string raw_handler_source(handler_source_buffer_->data(), result);
+  handler_source_buffer_ = NULL; // Free up some memory.
 
   AppCacheExecutableHandler* handler = cache_->GetOrCreateExecutableHandler(
-      entry_.response_id(), handler_source_buffer_.get());
-  handler_source_buffer_ = NULL;  // not needed anymore
+      entry_.response_id(), raw_handler_source);
   if (handler) {
     InvokeExecutableHandler(handler);
     return;
   }
 
   BeginErrorDelivery("factory failed to produce a handler");
 }
 
 void AppCacheURLRequestJob::InvokeExecutableHandler(
     AppCacheExecutableHandler* handler) {
+  net::URLRequest* req = request();
+
+  AppCacheExecutableHandler::Request request;
+  request.url = req->url();
+  request.is_main_resource_load = is_main_resource_load_;
+  request.method = req->method();
+  request.referrer = req->referrer();
+  net::HttpRequestHeaders headers;
+  req->GetFullRequestHeaders(&headers);
+  net::HttpRequestHeaders::Iterator iter(headers);
+  while (iter.GetNext())
+    request.headers.insert(make_pair(iter.name(), iter.value()));
+
   handler->HandleRequest(
-      request(),
+      request,
       base::Bind(&AppCacheURLRequestJob::OnExecutableResponseCallback,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheURLRequestJob::OnExecutableResponseCallback(
     const AppCacheExecutableHandler::Response& response) {
   DCHECK(!has_been_killed());
-  if (response.use_network) {
+
+  // Support for .respondWithNetwork(id)
+  if (response.use_default) {
     delivery_type_ = NETWORK_DELIVERY;
     storage_ = NULL;
     BeginDelivery();
     return;
   }
 
-  if (!response.cached_resource_url.is_empty()) {
-    AppCacheEntry* entry_ptr = cache_->GetEntry(response.cached_resource_url);
-    if (entry_ptr && !entry_ptr->IsExecutable()) {
-      entry_ = *entry_ptr;
-      BeginDelivery();
-      return;
+  // Support for .respondWith(blob) and .redirectTo(locataion);
+  if (response.status_code) {
+    // TODO(michaeln): synthesize a response with the response_code and
+    // the blob as the body.
+    webkit_blob::BlobStorageController* blob_storage =
+        storage_->service()->executable_handler_factory()->GetBlobStorageController();
+    fileapi::FileSystemContext* filesystem_context =
+        storage_->service()->executable_handler_factory()->GetFileSystemContext();
+
+    scoped_refptr<webkit_blob::BlobData> blob_data;
+    if (!response.blob_id.empty())
+      blob_data = blob_storage->GetBlobDataFromUrl(GURL(response.blob_id));
+
+    std::string raw_headers = base::StringPrintf(
+        "HTTP/1.0 %d %S", response.status_code, UTF16ToWide(response.status_text).data());
+    raw_headers.append(1, '\0');
+
+    // TODO(alecflett): content_type is totally messy because blob has
+    // a content type, as does the response body itself. Further, the
+    // response header may have additional information on it like
+    // 'text/html; charset=utf-8' - this code drastically simplifies
+    // by simply using the blob if they don't match.
+    string16 content_type;
+    for (std::map<string16, string16>::const_iterator iter = response.headers.begin();
+         iter != response.headers.end();
+         ++iter) {
+      if (LowerCaseEqualsASCII(iter->first, "content-type"))
+        content_type = iter->second;
+      else {
+        raw_headers.append(base::StringPrintf("%s: %s", UTF16ToUTF8(iter->first).data(), UTF16ToUTF8(iter->second).data()));
+        raw_headers.append(1, '\0');
+      }
     }
-  }
+    if (blob_data) {
+      if (content_type.empty())
+        content_type = UTF8ToUTF16(blob_data->content_type());
+      if (!EqualsASCII(content_type, blob_data->content_type()))
+        LOG(WARNING) << "Blob and header content types don't match, using " <<
+            content_type << ". (blob is " << blob_data->content_type() << " but header is " << content_type << ")";
+      raw_headers.append(base::StringPrintf(
+          "Content-Type: %s", UTF16ToUTF8(content_type).data()));
 
-  if (!response.redirect_url.is_empty()) {
-    // TODO(michaeln): playback a redirect
-    // response_headers_(new HttpResponseHeaders(response_headers)),
-    // fallthru for now to deliver an error
+      raw_headers.append(1, '\0');
+      // TODO: content-length header too
+      blob_reader_.reset(new webkit_blob::BlobReader(
+          blob_data.get(), filesystem_context));
+    }
+    raw_headers.append(2, '\0');
+    info_ = new AppCacheResponseInfo(
+        manifest_url_, MakeHttpResponseInfo(raw_headers), 0);
+    BeginSynthesizedDelivery();
+    return;
   }
 
   // Otherwise, return an error.
   BeginErrorDelivery("handler returned an invalid response");
 }
 
 void AppCacheURLRequestJob::BeginErrorDelivery(const char* message) {
   if (host_)
     host_->frontend()->OnLogMessage(host_->host_id(), LOG_ERROR, message);
   delivery_type_ = ERROR_DELIVERY;
   storage_ = NULL;
   BeginDelivery();
 }
 
+void AppCacheURLRequestJob::BeginSynthesizedDelivery() {
+  delivery_type_ = SYNTHESIZED_DELIVERY;
+  storage_ = NULL;
+  BeginDelivery();
+}
+
 AppCacheURLRequestJob::~AppCacheURLRequestJob() {
   if (storage_)
     storage_->CancelDelegateCallbacks(this);
 }
 
 void AppCacheURLRequestJob::OnResponseInfoLoaded(
       AppCacheResponseInfo* response_info, int64 response_id) {
   DCHECK(is_delivering_appcache_response());
   scoped_refptr<AppCacheURLRequestJob> protect(this);
   if (response_info) {
@@ skipping 101 matching lines @@
     net::URLRequestJob::Kill();
     weak_factory_.InvalidateWeakPtrs();
   }
 }
 
 net::LoadState AppCacheURLRequestJob::GetLoadState() const {
   if (!has_been_started())
     return net::LOAD_STATE_IDLE;
   if (!has_delivery_orders())
     return net::LOAD_STATE_WAITING_FOR_APPCACHE;
-  if (delivery_type_ != APPCACHED_DELIVERY)
+  if (delivery_type_ != APPCACHED_DELIVERY &&
+      delivery_type_ != SYNTHESIZED_DELIVERY)
     return net::LOAD_STATE_IDLE;
   if (!info_.get())
     return net::LOAD_STATE_WAITING_FOR_APPCACHE;
   if (reader_.get() && reader_->IsReadPending())
     return net::LOAD_STATE_READING_RESPONSE;
   return net::LOAD_STATE_IDLE;
 }
 
 bool AppCacheURLRequestJob::GetMimeType(std::string* mime_type) const {
   if (!http_info())
@@ skipping 14 matching lines @@
 }
 
 int AppCacheURLRequestJob::GetResponseCode() const {
   if (!http_info())
     return -1;
   return http_info()->headers->response_code();
 }
 
 bool AppCacheURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size,
                                         int *bytes_read) {
-  DCHECK(is_delivering_appcache_response());
+  DCHECK(is_delivering_appcache_response() ||
+         is_delivering_synthesized_response());
   DCHECK_NE(buf_size, 0);
   DCHECK(bytes_read);
+
+  // Branch to return a 'blob' response provided by an exe handler.
+  if (blob_reader_)
+    return ReadRawBlobData(buf, buf_size, bytes_read);
+
+  if (!reader_) {
+    // No raw data to read, an empty response body.
+    *bytes_read = 0;
+    return true;
+  }
+
   DCHECK(!reader_->IsReadPending());
   reader_->ReadData(
       buf, buf_size, base::Bind(&AppCacheURLRequestJob::OnReadComplete,
                                 base::Unretained(this)));
   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   return false;
 }
 
+bool AppCacheURLRequestJob::ReadRawBlobData(net::IOBuffer* buf, int buf_size,
+                                            int *bytes_read) {
+  DCHECK(is_delivering_synthesized_response());
+  DCHECK_NE(buf_size, 0);
+  DCHECK(bytes_read);
+
+  int rv = blob_reader_->Read(
+      buf, buf_size, base::Bind(&AppCacheURLRequestJob::OnReadBlobDataComplete,
+                                base::Unretained(this)));
+  SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
+  if (rv != net::ERR_IO_PENDING) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&AppCacheURLRequestJob::OnReadBlobDataComplete,
+                              weak_factory_.GetWeakPtr(), rv));
+  }
+  return false;
+}
+
+void AppCacheURLRequestJob::OnReadBlobDataComplete(int result) {
+  DCHECK(is_delivering_synthesized_response());
+  if (result == 0)
+    NotifyDone(net::URLRequestStatus());
+  else if (result < 0)
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
+  else
+    SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status
+  NotifyReadComplete(result);
+}
+
+
 void AppCacheURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
   std::string value;
   std::vector<net::HttpByteRange> ranges;
   if (!headers.GetHeader(net::HttpRequestHeaders::kRange, &value) ||
       !net::HttpUtil::ParseRangeHeader(value, &ranges)) {
     return;
   }
 
   // If multiple ranges are requested, we play dumb and
   // return the entire response with 200 OK.
   if (ranges.size() == 1U)
     range_requested_ = ranges[0];
 }
 
 }  // namespace appcache