Implement chrome://view-http-cache with network service.

content/network/cache_url_loader.cc

+// Copyright 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/network/cache_url_loader.h"
+
+#include "base/bind.h"
+#include "base/macros.h"
+#include "base/strings/string_util.h"
+#include "content/public/common/url_constants.h"
+#include "mojo/common/data_pipe_utils.h"
+#include "net/url_request/view_cache_helper.h"
+
+namespace content {
+
+namespace {
+
+class CacheURLLoader {
+ public:
+  CacheURLLoader(const ResourceRequest& request,
+                 net::URLRequestContext* request_context,
+                 mojom::URLLoaderClientPtr client)
+      : client_(std::move(client)) {
+    scoped_refptr<net::HttpResponseHeaders> headers(
+        new net::HttpResponseHeaders("HTTP/1.1 200 OK"));
+    ResourceResponseHead resource_response;
+    resource_response.headers = headers;
+    resource_response.mime_type = "text/html";
+    client_->OnReceiveResponse(resource_response, base::nullopt, nullptr);
+
+    std::string cache_key =
+        request.url.spec().substr(strlen(kChromeUINetworkViewCacheURL));
+
+    int rv;
+    if (cache_key.empty()) {
+      rv = cache_helper_.GetContentsHTML(
+          request_context, kChromeUINetworkViewCacheURL, &data_,
+          base::Bind(&CacheURLLoader::DataAvailable, base::Unretained(this)));
+    } else {
+      rv = cache_helper_.GetEntryInfoHTML(
+          cache_key, request_context, &data_,
+          base::Bind(&CacheURLLoader::DataAvailable, base::Unretained(this)));
+    }
+
+    if (rv != net::ERR_IO_PENDING)
+      DataAvailable(rv);
+  }
+
+ private:
+  ~CacheURLLoader() {}
+
+  void DataAvailable(int result) {
+    DCHECK_EQ(net::OK, result);
+    MojoCreateDataPipeOptions options;
+    options.struct_size = sizeof(MojoCreateDataPipeOptions);
+    options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
+    options.element_num_bytes = 1;
+    options.capacity_num_bytes = data_.size();
+    mojo::DataPipe data_pipe(options);
+
+    DCHECK(data_pipe.producer_handle.is_valid());
+    DCHECK(data_pipe.consumer_handle.is_valid());
+
+    CHECK(
+        mojo::common::BlockingCopyFromString(data_, data_pipe.producer_handle));

[mmenke, 2017/05/10 18:52:30]

Since we haven't set the consumer end of the pipe anywhere yet, does this just
create a copy of the entire buffer in memory?  Can this fail if the file is too
big?

[jam, 2017/05/10 22:02:53]

The buffer was already created online 59. That's the 2nd copy in memory, since
the cache helper also created a string of that size.

[mmenke, 2017/05/10 22:42:36]

I wasn't thinking about OOM, so much as if there's some mojo limit that would
cause it to refuse to do something crazy if we ask it to, or if there's some
other reason BlockingCopyFromString could fail.

In which case, just tossing an error to client_ instead of a CHECK would be
better.  Anyhow, if you're confident that OOM is the only potential issue here
(Which I'm fine with, since it's a pre-existing issue...this does make it worse,
but not that much worse).

[jam, 2017/05/10 23:05:25]

yeah, I added CHECKs in all the url loaders so that only if this is getting hit
do we need to worry about adding more complicated code.

+
+    client_->OnStartLoadingResponseBody(std::move(data_pipe.consumer_handle));
+
+    ResourceRequestCompletionStatus request_complete_data;
+    request_complete_data.error_code = net::OK;
+    request_complete_data.exists_in_cache = false;
+    request_complete_data.completion_time = base::TimeTicks::Now();
+    request_complete_data.encoded_data_length = data_.size();
+    request_complete_data.encoded_body_length = data_.size();
+    client_->OnComplete(request_complete_data);
+    delete this;
+  }
+
+  std::string data_;
+  mojom::URLLoaderClientPtr client_;
+  net::ViewCacheHelper cache_helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(CacheURLLoader);
+};
+}
+
+void StartCacheURLLoader(const ResourceRequest& request,
+                         net::URLRequestContext* request_context,
+                         mojom::URLLoaderClientPtr client) {
+  new CacheURLLoader(request, request_context, std::move(client));
+}
+
+}  // namespace content