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/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) {}
+                                                    bool is_fallback) {
+  delivery_type_ = APPCACHED_DELIVERY;
 
-void AppCacheURLLoaderJob::DeliverNetworkResponse() {}
+  AppCacheHistograms::AddAppCacheJobStartDelaySample(base::TimeTicks::Now() -
+                                                     start_time_tick_);
 
-void AppCacheURLLoaderJob::DeliverErrorResponse() {}
+  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_);
+
+  if (delegate_)
+    delegate_->SendNetworkResponse();
+}
+
+void AppCacheURLLoaderJob::DeliverErrorResponse() {
+  delivery_type_ = ERROR_DELIVERY;
+
+  AppCacheHistograms::AddErrorJobStartDelaySample(base::TimeTicks::Now() -
+                                                  start_time_tick_);
+
+  if (delegate_)
+    delegate_->SendErrorResponse();
+}
 
 const GURL& AppCacheURLLoaderJob::GetURL() const {
-  return url_;
+  return request_.url;
 }
 
-AppCacheURLLoaderJob::AppCacheURLLoaderJob() {}
+AppCacheURLLoaderJob* AppCacheURLLoaderJob::AsURLLoaderJob() {
+  return this;
+}
+
+AppCacheURLLoaderJob::AppCacheURLLoaderJob(const ResourceRequest& request,
+                                           AppCacheStorage* storage)
+    : request_(request),
+      delegate_(nullptr),
+      storage_(storage),
+      start_time_tick_(base::TimeTicks::Now()),
+      cache_id_(kAppCacheNoCacheId),
+      is_fallback_(false),
+      buffer_(nullptr) {}
+
+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 (delegate_)
+      delegate_->HandleAppCacheResponseStart(response_info);
+  } 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 (delegate_)
+    delegate_->HandleAppCacheData(buffer_.get(), result);

[michaeln, 2017/06/02 01:18:00]

What causes the reader to read more? We need to call ReadData() again to read
the next buffer worth of stuff, and so on.

[ananta, 2017/06/02 03:19:57]

Thanks for pointing that out. We now control this via a callback passed in here.
The delegate invokes it when it has read the data out of the buffer so we can
continue reading forward.

[ananta, 2017/06/03 01:55:55]

Please look at the updated patch. We continue reading until we get 0 bytes.

+}
 
 }  // namespace content