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(
+      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.
+}
 
 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;
+

[kinuko, 2017/06/06 08:07:30]

DCHECK(!binding_); ?

[ananta, 2017/06/06 20:49:16]

Not needed now.

+  binding_.reset(new mojo::AssociatedBinding<mojom::URLLoader>(
+      this, std::move(url_loader_request)));

[kinuko, 2017/06/06 08:07:30]

nit: I think we can also do something like:

 binding_(this)

in ctor and

 DCHECK(!binding_.is_bound());
 binding_.Bind(std::move(url_loader_request));

here

[ananta, 2017/06/06 20:49:15]

Done.

+  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),
+      routing_id_(-1),
+      request_id_(-1) {}
+
+void AppCacheURLLoaderJob::OnResponseInfoLoaded(
+    AppCacheResponseInfo* response_info,
+    int64_t response_id) {
+  DCHECK(IsDeliveringAppCacheResponse());
+
+  if (response_info) {
+    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()));
+    reader_->ReadData(buffer_.get(), info_->response_data_size(),
+                      base::Bind(&AppCacheURLLoaderJob::OnReadComplete,
+                                 base::Unretained(this)));
+    if (client_info_)
+      SendResponseInfo();
+  } else {
+    // Error case here. We fallback to the network.
+    DeliverNetworkResponse();
+    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();
+    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(),
+                       &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() {
+  delete 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);) {
+    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