Get main frame and subframe AppCache loads to work.

content/browser/appcache/appcache_url_loader_job.cc

 // Copyright (c) 2017 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 "content/browser/appcache/appcache_url_loader_job.h"
-#include "content/browser/appcache/appcache_entry.h"
+#include "content/browser/appcache/appcache_histograms.h"
+#include "content/browser/url_loader_factory_getter.h"
+#include "content/public/common/resource_type.h"
+#include "net/base/io_buffer.h"
 
 namespace content {
 
 AppCacheURLLoaderJob::~AppCacheURLLoaderJob() {}
 
 void AppCacheURLLoaderJob::Kill() {}
 
 bool AppCacheURLLoaderJob::IsStarted() const {
-  return false;
-}
-
-bool AppCacheURLLoaderJob::IsWaiting() const {
-  return false;
-}
-
-bool AppCacheURLLoaderJob::IsDeliveringAppCacheResponse() const {
-  return false;
-}
-
-bool AppCacheURLLoaderJob::IsDeliveringNetworkResponse() const {
-  return false;
-}
-
-bool AppCacheURLLoaderJob::IsDeliveringErrorResponse() const {
-  return false;
-}
-
-bool AppCacheURLLoaderJob::IsCacheEntryNotFound() const {
-  return false;
+  return delivery_type_ != AWAITING_DELIVERY_ORDERS;
 }
 
 void AppCacheURLLoaderJob::DeliverAppCachedResponse(const GURL& manifest_url,
                                                     int64_t cache_id,
                                                     const AppCacheEntry& entry,
-                                                    bool is_fallback) {}
-
-void AppCacheURLLoaderJob::DeliverNetworkResponse() {}
-
-void AppCacheURLLoaderJob::DeliverErrorResponse() {}
+                                                    bool is_fallback) {
+  delivery_type_ = APPCACHED_DELIVERY;
+
+  AppCacheHistograms::AddAppCacheJobStartDelaySample(base::TimeTicks::Now() -
+                                                     start_time_tick_);
+
+  manifest_url_ = manifest_url;
+  cache_id_ = cache_id;
+  entry_ = entry;
+  is_fallback_ = is_fallback;
+
+  storage_->LoadResponseInfo(manifest_url_, entry_.response_id(), this);
+}
+
+void AppCacheURLLoaderJob::DeliverNetworkResponse() {
+  delivery_type_ = NETWORK_DELIVERY;
+
+  AppCacheHistograms::AddNetworkJobStartDelaySample(base::TimeTicks::Now() -
+                                                    start_time_tick_);
+
+  url_loader_factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(

[michaeln, 2017/06/07 02:53:46]

I think we want to defer to the network by calling the LoaderFactoryCallback
with nullptr so the NavigationURLLoaderNetworkService class tries the next
'handler' in its list.

To do that, we probably should defer calling the LoaderCallback until the
ResponseInfo has been successfully loaded.

[ananta, 2017/06/08 05:58:39]

I added call to the loader callback here. We return after invoking the callback
if
we have one. I left the factory stuff here for now. Will revisit this in the
next patch where we start looking at subresources

+      mojo::MakeRequest(&url_loader_network_), routing_id_, request_id_,
+      mojom::kURLLoadOptionSendSSLInfo, request_, std::move(client_info_));
+}
+
+void AppCacheURLLoaderJob::DeliverErrorResponse() {
+  delivery_type_ = ERROR_DELIVERY;
+
+  AppCacheHistograms::AddErrorJobStartDelaySample(base::TimeTicks::Now() -
+                                                  start_time_tick_);
+  // TODO(ananta)
+  // Add support to send out an error response.

[michaeln, 2017/06/07 02:53:46]

see BlobURLLoader::NotifyCompleted() for an example of how to do that

[ananta, 2017/06/08 05:58:39]

Added a small implementation of NotifyCompleted(). Needs more work for
generating an error response etc. Will do that in a later patch. Added TODOs to
that effect.

+}
 
 const GURL& AppCacheURLLoaderJob::GetURL() const {
-  return url_;
-}
-
-AppCacheURLLoaderJob::AppCacheURLLoaderJob() {}
+  return request_.url;
+}
+
+AppCacheURLLoaderJob* AppCacheURLLoaderJob::AsURLLoaderJob() {
+  return this;
+}
+
+void AppCacheURLLoaderJob::FollowRedirect() {
+  if (url_loader_network_)
+    url_loader_network_->FollowRedirect();
+}
+
+void AppCacheURLLoaderJob::SetPriority(net::RequestPriority priority,
+                                       int32_t intra_priority_value) {
+  NOTREACHED() << "We don't support SetPriority()";
+}
+
+void AppCacheURLLoaderJob::BindEndpoints(
+    const ResourceRequest& request,
+    mojom::URLLoaderAssociatedRequest url_loader_request,
+    int32_t routing_id,
+    int32_t request_id,
+    mojom::URLLoaderClientPtrInfo client_info) {
+  request_ = request;
+
+  DCHECK(!binding_.is_bound());
+  binding_.Bind(std::move(url_loader_request));
+
+  binding_.set_connection_error_handler(base::Bind(
+      &AppCacheURLLoaderJob::OnConnectionError, base::Unretained(this)));
+
+  routing_id_ = routing_id;
+  request_id_ = request_id;
+
+  client_info_.Bind(std::move(client_info));
+
+  // Send the cached AppCacheResponse if any.
+  if (info_.get())
+    SendResponseInfo();
+}
+
+void AppCacheURLLoaderJob::SetURLLoaderFactoryGetter(
+    URLLoaderFactoryGetter* url_loader_factory_getter) {
+  url_loader_factory_getter_ = url_loader_factory_getter;
+}
+
+AppCacheURLLoaderJob::AppCacheURLLoaderJob(const ResourceRequest& request,
+                                           AppCacheStorage* storage)
+    : request_(request),
+      storage_(storage),
+      start_time_tick_(base::TimeTicks::Now()),
+      cache_id_(kAppCacheNoCacheId),
+      is_fallback_(false),
+      buffer_(nullptr),
+      binding_(this),
+      routing_id_(-1),
+      request_id_(-1) {}
+
+void AppCacheURLLoaderJob::OnResponseInfoLoaded(
+    AppCacheResponseInfo* response_info,
+    int64_t response_id) {
+  DCHECK(IsDeliveringAppCacheResponse());
+
+  if (response_info) {

[michaeln, 2017/06/07 02:53:46]

We shouldn't consume the LoaderRequest until here, I think we want to call
LoaderCallback(this) right at this point.

[ananta, 2017/06/08 05:58:39]

Thanks. makes sense. done

+    info_ = response_info;
+    reader_.reset(
+        storage_->CreateResponseReader(manifest_url_, entry_.response_id()));
+
+    // TODO(ananta)
+    // Handle range requests.
+
+    buffer_ =
+        new net::IOBuffer(static_cast<size_t>(info_->response_data_size()));

[jam, 2017/06/07 01:42:17]

what if the response is really big, this would end up creating a buffer that
size? also what if the data pipe was smaller than this?

I think using the helper class in content/common would fix these, so should use
these from the start.

[ananta, 2017/06/07 20:57:16]

Done.

+    reader_->ReadData(buffer_.get(), info_->response_data_size(),
+                      base::Bind(&AppCacheURLLoaderJob::OnReadComplete,
+                                 StaticAsWeakPtr(this)));
+    if (client_info_)
+      SendResponseInfo();
+  } else {
+    // Error case here. We fallback to the network.
+    DeliverNetworkResponse();

[michaeln, 2017/06/07 02:53:45]

We should call LoaderCallback(nullptr) here to go on to the next in the handler
chain.

[ananta, 2017/06/07 20:57:16]

I don't think we can do that at this point. It is a single use callback.
Added a TODO here to look into a good way to handle this going forward

[michaeln, 2017/06/08 02:54:01]

I'm suggesting that we should defer calling the LoaderCallback until we're
inside this method, if we read good response info, LoaderCallback(this), and if
we don't get good info, LoaderCallback(nullptr). Then kinuko's class will invoke
the next in the chain.

The DeliverNetworkResponse method can call LoaderCallback(nullptr) and the
OnResponseInfoLoaded can call LoaderCallback(this) when we get good info. Those
are the two primary callsites for the LoaderCallback. We'd need the third in
AppCacheRequestHandler::MaybeCreateLoaderFactory for when we don't construct a
job at all.

[ananta, 2017/06/08 05:58:39]

Done.

+    AppCacheHistograms::CountResponseRetrieval(
+        false, IsResourceTypeFrame(request_.resource_type),
+        manifest_url_.GetOrigin());
+
+    cache_entry_not_found_ = true;
+  }
+}
+
+void AppCacheURLLoaderJob::OnCacheLoaded(AppCache* cache, int64_t cache_id) {
+  NOTREACHED() << "Unhandled at the moment.";
+}
+
+void AppCacheURLLoaderJob::OnReadComplete(int result) {
+  DLOG(WARNING) << "AppCache read completed with result: " << result;
+
+  bool is_main_resource = IsResourceTypeFrame(request_.resource_type);
+
+  if (result == 0) {
+    AppCacheHistograms::CountResponseRetrieval(true, is_main_resource,
+                                               manifest_url_.GetOrigin());
+  } else if (result < 0) {
+    // Error case here. We fallback to the network.
+    DeliverNetworkResponse();

[michaeln, 2017/06/07 02:53:46]

At this point, it's too late to fallback to the network, we've already sent a
response head and now have failed to load the body, we need to call an internal
NotifyFailure method that signals the client about the failure. The
BlobURLLoaderFactory has a good example in NotifyComplete.

[ananta, 2017/06/07 20:57:16]

Added a call to oncomplete here. Will work on it in the next patchsets.

+    AppCacheHistograms::CountResponseRetrieval(false, is_main_resource,
+                                               manifest_url_.GetOrigin());
+    return;
+  }
+
+  if (result > 0) {
+    uint32_t bytes_written = static_cast<uint32_t>(result);
+    // TODO(ananta)
+    // Use the IO buffer net adapter to efficiently pass the data over to the
+    // cliet.
+    mojo::WriteDataRaw(data_pipe_.producer_handle.get(), buffer_->data(),

[michaeln, 2017/06/07 02:53:46]

We're assuming a MOJO_RESULT_OK here, if the resource is large, we'll definitely
run into MOJO_RESULT_SHOULD_WAIT. If possible, it'd be nice to get the data
streaming aspects taken care of in this CL, where we read some, write some, read
some more. But if not, We could put a CHECK(MOJO_RESULT_OK) to check the
assumption.

[ananta, 2017/06/07 20:57:16]

Code has changed to async

+                       &bytes_written, MOJO_WRITE_DATA_FLAG_NONE);
+    reader_->ReadData(buffer_.get(), info_->response_data_size(),
+                      base::Bind(&AppCacheURLLoaderJob::OnReadComplete,
+                                 base::Unretained(this)));
+  }
+}
+
+void AppCacheURLLoaderJob::OnConnectionError() {
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
+}
+
+void AppCacheURLLoaderJob::SendResponseInfo() {
+  DCHECK(client_info_);
+
+  const net::HttpResponseInfo* http_info = info_->http_response_info();
+
+  ResourceResponseHead response_head;
+  response_head.headers = new net::HttpResponseHeaders("");
+
+  std::string name;
+  std::string value;
+
+  for (size_t it = 0;
+       http_info->headers->EnumerateHeaderLines(&it, &name, &value);) {

[michaeln, 2017/06/07 02:53:46]

HttpResponseHeaders is a refcounted object, would it work to refer to the same
object here instead of making a complete copy?

reasons_head.headers = http_info->headers;

[ananta, 2017/06/07 20:57:16]

Thanks done.

+    response_head.headers->AddHeader(name + ": " + value);
+  }
+
+  // TODO(ananta)
+  // Copy more fields.
+  http_info->headers->GetMimeType(&response_head.mime_type);
+  http_info->headers->GetCharset(&response_head.charset);
+
+  response_head.request_time = http_info->request_time;
+  response_head.response_time = http_info->response_time;
+  response_head.content_length = info_->response_data_size();
+
+  client_info_->OnReceiveResponse(response_head, http_info->ssl_info,
+                                  mojom::DownloadedTempFilePtr());
+
+  client_info_->OnStartLoadingResponseBody(
+      std::move(data_pipe_.consumer_handle));
+}
 
 }  // namespace content