Create a proprietary scheme for loading web-accessible resources.

content/browser/resource_protocol.cc

+// Copyright 2014 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/resource_protocol.h"
+
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+#include "blink/public/resources/grit/blink_resources.h"
+#include "content/public/common/content_client.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_response_info.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_job_factory.h"
+#include "net/url_request/url_request_simple_job.h"
+#include "ui/base/layout.h"
+
+namespace content {
+namespace {
+
+struct BuiltinWebAccessibleResource {
+  const char* path;
+  int resource_id;
+  ui::ScaleFactor scale_factor;
+  const char* content_type;
+};
+
+static const char kBlinkHostname[] = "blink";
+static const BuiltinWebAccessibleResource kBlinkWebAccessibleResources[] = {
+    // Warning: Resources in this list are exposed to all web content.
+    // Carefully consider whether the resource could be used for XSS before
+    // including it.
+    // TODO(jbroman): Put actual resources in here.
+};
+
+class URLRequestResourceJob : public net::URLRequestSimpleJob {
+ public:
+  using WebAccessibleResource = ResourceProtocolHandler::WebAccessibleResource;
+
+  URLRequestResourceJob(net::URLRequest* request,
+                        net::NetworkDelegate* network_delegate,
+                        const WebAccessibleResource& resource_info,
+                        ContentClient* content_client)
+      : net::URLRequestSimpleJob(request, network_delegate),
+        resource_info_(resource_info),
+        content_client_(content_client) {
+    std::string raw_headers("HTTP/1.1 200 OK");
+    raw_headers.append(2, '\0');
+    response_headers_ = new net::HttpResponseHeaders(raw_headers);
+  }
+
+  // Overridden from net::URLRequestSimpleJob:
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* data,
+              const net::CompletionCallback& callback) const override {
+    *data = GetContentClient()
+                ->GetDataResource(resource_info_.resource_id,

[jbroman, 2014/11/14 18:46:35]

It seems to be okay to call both content::GetContentClient and
content::ContentClient::GetDataResource from this thread, but I can't find
documentation to make me confident of this. Is this correct?

+                                  resource_info_.scale_factor)
+                .as_string();
+
+    response_headers_->AddHeader(base::StringPrintf(
+        "%s: %" PRIuS, net::HttpRequestHeaders::kContentLength, data->size()));
+
+    response_headers_->AddHeader(
+        base::StringPrintf("%s: %s", net::HttpRequestHeaders::kContentType,
+                           resource_info_.content_type.c_str()));
+    response_headers_->GetMimeTypeAndCharset(mime_type, charset);
+
+    return net::OK;
+  }
+
+  void GetResponseInfo(net::HttpResponseInfo* info) override {
+    info->headers = response_headers_;
+  }
+
+ private:
+  ~URLRequestResourceJob() override {}
+
+  ContentClient* GetContentClient() const {
+    return content_client_ ? content_client_ : content::GetContentClient();
+  }
+
+  WebAccessibleResource resource_info_;
+  scoped_refptr<net::HttpResponseHeaders> response_headers_;
+  ContentClient* content_client_;
+};
+
+}  // namespace
+
+ResourceProtocolHandler::ResourceProtocolHandler()
+    : ResourceProtocolHandler(nullptr) {
+}
+
+ResourceProtocolHandler::ResourceProtocolHandler(ContentClient* content_client)
+    : content_client_(content_client) {
+  std::string hostname = kBlinkHostname;
+  for (const auto& resource : kBlinkWebAccessibleResources) {
+    RegisterResource(hostname, resource.path, resource.resource_id,
+                     resource.scale_factor, resource.content_type);
+  }
+}
+
+ResourceProtocolHandler::~ResourceProtocolHandler() {
+}
+
+void ResourceProtocolHandler::RegisterResource(
+    const std::string& host,
+    const std::string& path,
+    int resource_id,
+    ui::ScaleFactor scale_factor,
+    const std::string& content_type) {
+  WebAccessibleResource& resource_info = resources_[std::make_pair(host, path)];
+  resource_info.resource_id = resource_id;
+  resource_info.scale_factor = scale_factor;
+  resource_info.content_type = content_type;
+}
+
+net::URLRequestJob* ResourceProtocolHandler::MaybeCreateJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  DCHECK(request);
+  DCHECK(request->url().is_valid());
+
+  const auto& url = request->url();
+  auto it = resources_.find(std::make_pair(url.host(), url.path()));
+  if (it != resources_.end()) {
+    return new URLRequestResourceJob(request, network_delegate, it->second,
+                                     content_client_);
+  }
+
+  return new net::URLRequestErrorJob(request, network_delegate,
+                                     net::ERR_FILE_NOT_FOUND);
+}
+
+bool ResourceProtocolHandler::IsSafeRedirectTarget(const GURL& location) const {
+  return false;
+}
+
+}  // namespace content