[NotLanded] Implement the fetching algorithm of the Web Manifest.

Source/core/loader/ManifestLoaderTest.cpp

Index: Source/core/loader/ManifestLoaderTest.cpp
diff --git a/Source/core/loader/ManifestLoaderTest.cpp b/Source/core/loader/ManifestLoaderTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db64902ae1f4253a3658c0fce8cd84d3976dd8c5
--- /dev/null
+++ b/Source/core/loader/ManifestLoaderTest.cpp
@@ -0,0 +1,303 @@
+// 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 "config.h"
+#include "core/loader/ManifestLoader.h"
+
+#include "core/html/HTMLHeadElement.h"
+#include "core/html/HTMLLinkElement.h"
+#include "core/testing/DummyPageHolder.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebManifestRequest.h"
+#include "public/platform/WebURL.h"
+#include "public/platform/WebURLResponse.h"
+#include "public/platform/WebUnitTestSupport.h"
+#include <gtest/gtest.h>
+
+using namespace WebCore;
+
+namespace {
+
+class ManifestRequest : public blink::WebManifestRequest {
+public:
+    ManifestRequest()
+        : m_succeeded(false)
+        , m_failed(false)
+    {
+    }
+
+    virtual void requestSucceeded(const blink::WebManifest&) OVERRIDE
+    {
+        ASSERT(!m_failed && !m_succeeded);
+        m_succeeded = true;
+    }
+
+    virtual void requestFailed(FailureReason reason) OVERRIDE
+    {
+        ASSERT(!m_failed && !m_succeeded);
+        m_failed = true;
+        m_reason = reason;
+    }
+
+    bool succeeded() const { return m_succeeded; }
+    bool failed() const { return m_failed; }
+    FailureReason reason() const { return m_reason; }
+
+private:
+    bool m_succeeded;
+    bool m_failed;
+    FailureReason m_reason;
+};
+
+class ManifestLoaderTest : public ::testing::Test {
+protected:
+    enum CORSType {
+        NoCORS,
+        CORSEmptyString,
+        CORSAnonymous,
+        CORSUseCredentials
+    };
+
+    virtual void SetUp() OVERRIDE;
+    virtual void TearDown() OVERRIDE;
+
+    void setURL(const String& url)
+    {
+        m_url = KURL(ParsedURLString, url);
+    }
+
+    void setupSuccessResponse();
+    void setup404Response();
+    void setupLinkManifest(CORSType);
+    void loadManifestSynchronously();
+
+    Document* document() { return &m_dummyPageHolder->document(); }
+    ManifestRequest* request() { return &m_request; }
+
+private:
+    OwnPtr<DummyPageHolder> m_dummyPageHolder;
+    ManifestRequest m_request;
+    KURL m_url;
+};
+
+void ManifestLoaderTest::SetUp()
+{
+    m_dummyPageHolder = DummyPageHolder::create();
+    KURL url(ParsedURLString, "http://foo.com/index.html");
+    document()->setURL(url);
+    document()->updateSecurityOrigin(SecurityOrigin::create(url));

[dcheng, 2014/07/28 17:08:57]

I commented on this in an earlier review pass. Can we just use the normal loader
steps for loading a document rather than trying to emulate them?

[mlamouri (slow - plz ping), 2014/08/19 16:14:18]

Do you mean doing a loading via a mocked url and then ask the frame to load the
given url? That's a fairly involved process that most tests do via
FrameTestHelpers, which lives in web/tests/.

Note that the intent here is not to simulate the document loading but to simply
set up the document in order to test ManifestLoader. The class uses a very
limited information from the document (baseURL(), securityOrigin(), fetcher(),
encoding(), linkManifest()). I'm not really convinced that doing the entire
loading process would be the right thing to do here. The goal is to test that if
the document's url and security origin has the correct impact on ManifestLoader,
not to test if they are set properly when the frame is loaded.

[dcheng, 2014/08/19 16:30:29]

Many of these properties are normally set by the loading process. Why would it
be better to bypass that for these tests?

[mlamouri (slow - plz ping), 2014/08/19 16:37:04]

The goal is to have unit tests for ManifestLoader so I want to have minimal
dependencies on anything else. The behaviour of the loading code is going to be
useless dependency that could just introduce noise. For example, if the loading
code is broken and doesn't set the security origin properly, this test would
break while the code it is testing would still be working properly.

It would make sense to load the document inside a WebView if that test was meant
to be an integration test because if the loading isn't working properly the
feature would indeed be broken.

+}
+
+void ManifestLoaderTest::TearDown()
+{
+    blink::Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
+}
+
+void ManifestLoaderTest::setupSuccessResponse()
+{
+    ASSERT(!m_url.isNull());
+
+    blink::WebURLResponse response;
+    response.initialize();
+    response.setMIMEType("application/manifest+json");
+    response.setURL(m_url);
+    WTF::String localPath = String(blink::Platform::current()->unitTestSupport()->webKitRootDir()) + "/Source/web/tests/data/manifest.json";
+    blink::Platform::current()->unitTestSupport()->registerMockedURL(m_url, response, localPath);
+}
+
+void ManifestLoaderTest::setup404Response()
+{
+    ASSERT(!m_url.isNull());
+
+    blink::WebURLResponse response;
+    response.initialize();
+    response.setMIMEType("application/manifest+json");
+    response.setHTTPStatusCode(404);
+    response.setURL(m_url);
+
+    blink::WebURLError error;
+    error.reason = 404; // We don't really care but we need a value.
+    blink::Platform::current()->unitTestSupport()->registerMockedErrorURL(m_url, response, error);
+}
+
+void ManifestLoaderTest::setupLinkManifest(CORSType cors)
+{
+    ASSERT(!m_url.isNull());
+
+    RefPtrWillBeRawPtr<HTMLLinkElement> link = HTMLLinkElement::create(*document(), false);
+    link->setAttribute(WebCore::HTMLNames::relAttr, "manifest");
+    link->setAttribute(WebCore::HTMLNames::hrefAttr, AtomicString(m_url.string()));
+    switch (cors) {
+    case CORSEmptyString:
+        link->setAttribute(WebCore::HTMLNames::crossoriginAttr, "");
+        break;
+    case CORSAnonymous:
+        link->setAttribute(WebCore::HTMLNames::crossoriginAttr, "anonymous");
+        break;
+    case CORSUseCredentials:
+        link->setAttribute(WebCore::HTMLNames::crossoriginAttr, "use-credentials");
+        break;
+    case NoCORS:
+        // do nothing.
+        break;
+    }
+    document()->head()->appendChild(link);

[dcheng, 2014/07/28 17:08:57]

This goes with my earlier comment. I don't think putting this logic in a helper
function makes this test clearer. We should just make 4 small test files and
dump them into Source/web/test. The combined length of those 4 test files will
probably be shorter than the length of this entire function, and it makes it
much easier to see exactly what's being tested.

[mlamouri (slow - plz ping), 2014/08/19 16:14:18]

I agree. On the other hand, that requires to do a proper loading of the file
while this is only setting the document in its bare minimum to be usable in this
unit test.

+}
+
+void ManifestLoaderTest::loadManifestSynchronously()
+{
+    // This call is wrapped in a helper call on purpose because we want to get
+    // rid of it. It will make the transition to the new model easier.
+    ManifestLoader::loadManifest(request(), document());
+    blink::Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();

[dcheng, 2014/07/28 17:08:57]

If you need this, you need this. Just ignore the presubmit error on this.
jyasskin and I have some long-term plans on how to eliminate the need for this.

[mlamouri (slow - plz ping), 2014/08/19 16:14:18]

Ok.

+}
+
+TEST_F(ManifestLoaderTest, NoLinkManifest)
+{
+    ManifestLoader::loadManifest(request(), document());
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NoLinkManifest, request()->reason());
+}
+
+TEST_F(ManifestLoaderTest, NoCORSValidURL)
+{
+    setURL("http://foo.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(NoCORS);
+
+    loadManifestSynchronously();
+
+    EXPECT_TRUE(request()->succeeded());
+    EXPECT_FALSE(request()->failed());
+}
+
+TEST_F(ManifestLoaderTest, NoCORSCrossOriginURL)
+{
+    setURL("http://example.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(NoCORS);
+
+    loadManifestSynchronously();
+
+    EXPECT_TRUE(request()->succeeded());
+    EXPECT_FALSE(request()->failed());
+}
+
+TEST_F(ManifestLoaderTest, CORSAnonymousValidURL)
+{
+    setURL("http://foo.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(CORSAnonymous);
+
+    loadManifestSynchronously();
+
+    EXPECT_TRUE(request()->succeeded());
+    EXPECT_FALSE(request()->failed());
+}
+
+TEST_F(ManifestLoaderTest, CORSDefaultValidURL)
+{
+    setURL("http://foo.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(CORSEmptyString);
+
+    loadManifestSynchronously();
+
+    EXPECT_TRUE(request()->succeeded());
+    EXPECT_FALSE(request()->failed());
+}
+
+TEST_F(ManifestLoaderTest, CORSUseCredentialsValidURL)
+{
+    setURL("http://foo.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(CORSUseCredentials);
+
+    loadManifestSynchronously();
+
+    EXPECT_TRUE(request()->succeeded());
+    EXPECT_FALSE(request()->failed());
+}
+
+TEST_F(ManifestLoaderTest, CORSAnonymousCrossOriginURL)
+{
+    setURL("http://example.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(CORSAnonymous);
+
+    loadManifestSynchronously();
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NetworkError, request()->reason());
+}
+
+TEST_F(ManifestLoaderTest, CORSDefaultCrossOriginURL)
+{
+    setURL("http://example.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(CORSEmptyString);
+
+    loadManifestSynchronously();
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NetworkError, request()->reason());
+}
+
+TEST_F(ManifestLoaderTest, CORSUseCredentialsCrossOriginURL)
+{
+    setURL("http://example.com/manifest.json");
+    setupSuccessResponse();
+    setupLinkManifest(CORSUseCredentials);
+
+    loadManifestSynchronously();
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NetworkError, request()->reason());
+}
+
+TEST_F(ManifestLoaderTest, NoCORS404URL)
+{
+    setURL("http://foo.com/manifest.json");
+    setup404Response();
+    setupLinkManifest(NoCORS);
+
+    loadManifestSynchronously();
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NetworkError, request()->reason());
+}
+
+TEST_F(ManifestLoaderTest, CORS404URL)
+{
+    setURL("http://foo.com/manifest.json");
+    setup404Response();
+    setupLinkManifest(CORSEmptyString);
+
+    loadManifestSynchronously();
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NetworkError, request()->reason());
+}
+
+TEST_F(ManifestLoaderTest, CORS404CrossOriginURL)
+{
+    setURL("http://example.com/manifest.json");
+    setup404Response();
+    setupLinkManifest(CORSEmptyString);
+
+    loadManifestSynchronously();
+
+    EXPECT_FALSE(request()->succeeded());
+    EXPECT_TRUE(request()->failed());
+    EXPECT_EQ(blink::WebManifestRequest::NetworkError, request()->reason());
+}
+
+} // anonymous namespace