Implement ManifestFetcher, helper to fetch Web Manifests.

content/renderer/fetchers/manifest_fetcher.cc

Index: content/renderer/fetchers/manifest_fetcher.cc
diff --git a/content/renderer/fetchers/manifest_fetcher.cc b/content/renderer/fetchers/manifest_fetcher.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6697ffeb906a84572201701e8c055367f54e940a
--- /dev/null
+++ b/content/renderer/fetchers/manifest_fetcher.cc
@@ -0,0 +1,88 @@
+// 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/renderer/fetchers/manifest_fetcher.h"
+
+#include "third_party/WebKit/public/platform/WebURLError.h"
+#include "third_party/WebKit/public/platform/WebURLLoader.h"
+#include "third_party/WebKit/public/platform/WebURLRequest.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
+
+namespace content {
+
+ManifestFetcher::ManifestFetcher(const GURL& url)
+    : request_(url),
+      completed_(false) {
+}
+
+ManifestFetcher::~ManifestFetcher() {
+  if (!completed_ && loader_)
+    loader_->cancel();
+}
+
+void ManifestFetcher::Start(blink::WebFrame* frame, const Callback& callback) {
+  DCHECK(!loader_);
+  DCHECK(!request_.isNull());
+  DCHECK(callback_.is_null());
+  DCHECK(!completed_);
+  if (!request_.httpBody().isNull())
+    DCHECK_NE("GET", request_.httpMethod().utf8()) << "GETs can't have bodies.";
+
+  callback_ = callback;
+
+  request_.setRequestContext(blink::WebURLRequest::RequestContextManifest);

[kenneth.christiansen, 2014/09/05 13:13:44]

So it keeps part of your former patch?

[mlamouri (slow - plz ping), 2014/09/05 14:10:41]

No, WebURLRequest already has that. It's part of the fetch spec.

+  request_.setFrameType(blink::WebURLRequest::FrameTypeNone);
+  request_.setFirstPartyForCookies(frame->document().firstPartyForCookies());
+  frame->dispatchWillSendRequest(request_);
+  loader_.reset(frame->createAssociatedURLLoader());
+  loader_->loadAsynchronously(request_, this);
+
+  request_.reset();
+}
+
+void ManifestFetcher::RunCallback(const blink::WebURLResponse& response,
+                                  const std::string& data) {
+  completed_ = true;
+  if (callback_.is_null())
+    return;
+
+  Callback callback = callback_;
+  callback.Run(response, data);
+}
+
+void ManifestFetcher::didReceiveResponse(
+    blink::WebURLLoader* loader, const blink::WebURLResponse& response) {
+  DCHECK(!completed_);
+  response_ = response;
+}
+
+void ManifestFetcher::didReceiveData(
+    blink::WebURLLoader* loader,
+    const char* data,
+    int data_length,
+    int encoded_data_length) {
+  DCHECK(!completed_);
+  DCHECK(data_length > 0);
+
+  data_.append(data, data_length);
+}
+
+void ManifestFetcher::didFinishLoading(
+    blink::WebURLLoader* loader,
+    double finishTime,
+    int64_t total_encoded_data_length) {
+  DCHECK(!completed_);
+
+  RunCallback(response_, data_);
+}
+
+void ManifestFetcher::didFail(blink::WebURLLoader* loader,
+                              const blink::WebURLError& error) {
+  DCHECK(!completed_);
+
+  RunCallback(blink::WebURLResponse(), std::string());
+}
+
+} // namespace content