Get main frame and subframe AppCache loads to work.

content/browser/appcache/appcache_url_loader_job.h

 // 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.
 
 #ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_JOB_H_
 #define CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_JOB_H_
 
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
+#include "base/time/time.h"
+#include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_job.h"
+#include "content/browser/appcache/appcache_response.h"
+#include "content/browser/appcache/appcache_storage.h"
 #include "content/common/content_export.h"
+#include "content/common/resource_request.h"
+
+namespace net {
+class IOBuffer;
+}  // namespace net
 
 namespace content {
 
 class AppCacheHost;
 class AppCacheRequest;
 class AppCacheStorage;
 
 // AppCacheJob wrapper for a mojom::URLLoader implementation which returns
 // responses stored in the AppCache.
-class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob {
+class CONTENT_EXPORT AppCacheURLLoaderJob : public AppCacheJob,

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

To make fewer moving parts, would it make sense to have this class derive from
mojom::URLLoaderFactory and mojom::URLLoader? Here's the decomposition i have in
mind with fewer moving parts involved.

Parts List...

AppCacheRequestHandler : public URLLoaderRequestHandler;
AppCacheURLLoaderJob : public mojom URLLoaderFactory, public URLLoader;

Here's how they could fit together...

The NavigationURLLoaderNetworkService creates an appcache_handler in its handler
chain and calls its MaybeCreateLoaderFactory() method.

AppCacheRequestHandler->MaybeCreateLoaderFactory() would create a job internally
(% origin not found case). The AppCacheURLLoaderJob would store all the network
service specific stuff (mojom bindings, LoaderFactoryCallback). If the response
is not found, or there is an error reading the response info,
DeliverNetworkResponse() would pass nullptr to the factorycallback function.
Otherwise, the the LoaderFactoryCallback would get called at successful
OnResponseInfoLoaded() time. 


AppCacheURLLoaderJob->CreateLoaderAndStart(). That method would set up the mojo
bindings, start an appcache response reader, and plumb the response info and
data to the urlloader client.


That's a lot fewer parts (2 object instances vs 5) and it maintains the same
division of labor that we have in the URLRequest'land, where 'handlers' mostly
decide what to do and 'jobs' move the bytes around.

(AppCacheURLLoaderRequestHandler
AppCacheRequestHandler)
+
(AppCacheURLLoaderFactory
AppCacheURLLoaderJob
AppCacheURLLoader)

wdyt of collapsing things along these lines?

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

The class implements the URLLoader mojom. The factory is still implemented by
the AppCacheURLLoaderFactory class.

+                                            public AppCacheStorage::Delegate {
  public:
+  class Delegate {
+   public:
+    // Generally called when we don't have an AppCache response for the
+    // ongoing request.
+    virtual void SendNetworkResponse() {}
+
+    // Called when we want to send out an error response to the client.
+    virtual void SendErrorResponse() {}
+
+    // Called when we have a valid response from the AppCache.
+    virtual void HandleAppCacheResponseStart(
+        AppCacheResponseInfo* response_info) {}
+
+    // Called when we have valid AppCache data to send to the client.
+    virtual void HandleAppCacheData(net::IOBuffer* buffer, int buffer_fsize) {}
+  };
+
   ~AppCacheURLLoaderJob() override;
 
   // AppCacheJob overrides.
   void Kill() override;
   bool IsStarted() const override;
-  bool IsWaiting() const override;
-  bool IsDeliveringAppCacheResponse() const override;
-  bool IsDeliveringNetworkResponse() const override;
-  bool IsDeliveringErrorResponse() const override;
-  bool IsCacheEntryNotFound() const override;
   void DeliverAppCachedResponse(const GURL& manifest_url,
                                 int64_t cache_id,
                                 const AppCacheEntry& entry,
                                 bool is_fallback) override;
   void DeliverNetworkResponse() override;
   void DeliverErrorResponse() override;
   const GURL& GetURL() const override;
+  AppCacheURLLoaderJob* AsURLLoaderJob() override;
+
+  void set_delegate(Delegate* delegate) { delegate_ = delegate; }
 
  protected:
   // AppCacheJob::Create() creates this instance.
   friend class AppCacheJob;
 
-  AppCacheURLLoaderJob();
+  AppCacheURLLoaderJob(const ResourceRequest& request,
+                       AppCacheStorage* storage);
 
-  GURL url_;
+  // AppCacheStorage::Delegate methods
+  void OnResponseInfoLoaded(AppCacheResponseInfo* response_info,
+                            int64_t response_id) override;
+  void OnCacheLoaded(AppCache* cache, int64_t cache_id) override;
+
+  // AppCacheResponseReader completion callback
+  void OnReadComplete(int result);
+
+  // The current request.
+  ResourceRequest request_;
+
+  // The delegate is invoked when we have data to report from the AppCache,
+  // or if the request is to be sent directly to the n/w, etc.
+  Delegate* delegate_;
+
+  AppCacheStorage* storage_;
+
+  // The response details.
+  scoped_refptr<AppCacheResponseInfo> info_;
+
+  // Used to read the cache.
+  std::unique_ptr<AppCacheResponseReader> reader_;
+
+  // Time when the request started.
+  base::TimeTicks start_time_tick_;
+
+  // The AppCache manifest URL.
+  GURL manifest_url_;
+
+  // The AppCache id.
+  int64_t cache_id_;
+
+  AppCacheEntry entry_;
+
+  // Set to true if we are loading fallback content.
+  bool is_fallback_;
+
+  // The buffer used to read AppCache data.
+  scoped_refptr<net::IOBuffer> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheURLLoaderJob);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_JOB_H_