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..f9ace8e7cb82f2fb1450ea4393632369695c5caf
--- /dev/null
+++ b/content/renderer/fetchers/manifest_fetcher.cc
@@ -0,0 +1,96 @@
+// 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 "base/logging.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);
+  request_.setFrameType(blink::WebURLRequest::FrameTypeNone);

[Mike West, 2014/09/10 07:45:30]

The only difference between ResourceFetcherImpl and this method is the
hard-coded contexts and types.

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

Not really. I'm using frame->createAssociatedURLLoader() while
ResourceFetcherImpl uses Platform::current()->createURLLoader().

[Mike West, 2014/09/10 11:49:55]

You're right. I missed the difference in line #40.

Still.

+  request_.setFirstPartyForCookies(frame->document().firstPartyForCookies());
+  frame->dispatchWillSendRequest(request_);
+  loader_.reset(frame->createAssociatedURLLoader());
+  loader_->loadAsynchronously(request_, this);
+
+  request_.reset();
+}
+
+void ManifestFetcher::Cancel() {
+  DCHECK(!completed_ && loader_);
+
+  loader_->cancel();
+  RunCallback(blink::WebURLResponse(), std::string());
+}
+
+void ManifestFetcher::RunCallback(const blink::WebURLResponse& response,
+                                  const std::string& data) {
+  completed_ = true;

[Mike West, 2014/09/10 07:45:30]

The only difference here is the timeout.

+  if (callback_.is_null())
+    return;
+
+  Callback callback = callback_;
+  callback.Run(response, data);
+}
+
+void ManifestFetcher::didReceiveResponse(

[Mike West, 2014/09/10 07:45:30]

The implementation of these four methods is exactly the same as
ResourceFetcherImpl.

+    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