Implement URL and Origin typemaps/struct traits for blink.

third_party/WebKit/Source/platform/mojo/KURLSecurityOriginTest.cpp

+// Copyright 2016 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 "base/macros.h"
+#include "base/message_loop/message_loop.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/mojo/url_test.mojom-blink.h"
+#include "url/url_constants.h"
+
+namespace blink {
+namespace {
+
+class UrlTestImpl : public url::mojom::blink::UrlTest {
+public:
+    explicit UrlTestImpl(url::mojom::blink::UrlTestRequest request)
+        : m_binding(this, std::move(request))
+    {
+    }
+
+    // UrlTest:
+    void BounceUrl(const KURL& in, const BounceUrlCallback& callback) override
+    {
+        callback.Run(in);
+    }
+
+    void BounceOrigin(const RefPtr<SecurityOrigin>& in,
+        const BounceOriginCallback& callback) override
+    {
+        callback.Run(in);
+    }
+
+private:
+    mojo::Binding<UrlTest> m_binding;
+};
+
+} // namespace
+
+// Mojo version of chrome IPC test in url/ipc/url_param_traits_unittest.cc.
+TEST(KURLSecurityOriginStructTraitsTest, Basic)
+{
+    base::MessageLoop messageLoop;
+
+    url::mojom::blink::UrlTestPtr proxy;
+    UrlTestImpl impl(GetProxy(&proxy));
+
+    const char* serializeCases[] = {
+        "http://www.google.com/",
+        "http://user:pass@host.com:888/foo;bar?baz#nop",
+    };
+
+    for (size_t i = 0; i < arraysize(serializeCases); i++) {

[dcheng, 2016/05/26 20:15:15]

Thanks to the magic of C++11, you can just write:

  for (const char* testCase : serializeCases) {
    KURL input(KURL(), testCase);
    // ...
  }

[Marijn Kruisselbrink, 2016/05/26 20:52:42]

Good point, not sure why the non-blink version of this test didn't do it that
way.

+        KURL input(KURL(), serializeCases[i]);
+        KURL output;
+        EXPECT_TRUE(proxy->BounceUrl(input, &output));
+
+        // We want to test each component individually to make sure its range was
+        // correctly serialized and deserialized, not just the spec.
+        EXPECT_EQ(input.getString(), output.getString());
+        EXPECT_EQ(input.isValid(), output.isValid());
+        EXPECT_EQ(input.protocol(), output.protocol());
+        EXPECT_EQ(input.user(), output.user());
+        EXPECT_EQ(input.pass(), output.pass());
+        EXPECT_EQ(input.host(), output.host());
+        EXPECT_EQ(input.port(), output.port());
+        EXPECT_EQ(input.path(), output.path());
+        EXPECT_EQ(input.query(), output.query());
+        EXPECT_EQ(input.fragmentIdentifier(), output.fragmentIdentifier());
+    }
+
+    // Test an excessively long GURL.
+    {
+        const std::string url = std::string("http://example.org/").append(url::kMaxURLChars + 1, 'a');
+        KURL input(KURL(), url.c_str());
+        KURL output;
+        EXPECT_TRUE(proxy->BounceUrl(input, &output));
+        EXPECT_TRUE(output.isEmpty());
+    }
+
+    // Test basic Origin serialization.
+    RefPtr<SecurityOrigin> nonUnique = SecurityOrigin::create("http", "www.google.com", 80);
+    RefPtr<SecurityOrigin> output;
+    EXPECT_TRUE(proxy->BounceOrigin(nonUnique, &output));
+    EXPECT_TRUE(nonUnique->isSameSchemeHostPort(output.get()));
+    EXPECT_FALSE(nonUnique->isUnique());
+
+    RefPtr<SecurityOrigin> unique = SecurityOrigin::createUnique();
+    EXPECT_TRUE(proxy->BounceOrigin(unique, &output));
+    EXPECT_TRUE(output->isUnique());
+}
+
+} // namespace url