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 {

[esprehn, 2016/05/25 17:06:27]

don't indent nested namespace functions

[Marijn Kruisselbrink, 2016/05/25 17:35:08]

I never quite understood what "nested namespaces with the same scope" meant in
the blink style guide ("The contents of an outermost namespace block (and any
nested namespaces with the same scope) should not be indented. The contents of
other nested namespaces should be indented."), but assumed that it meant to
differentiate between "namespace a { namespace b {} class foo {}; }" and
"namespace a { namespace b { class foo {}; } }" where in the first one things
inside b should be indented, while in the second one it shouldn't. Maybe my
understanding of the style guide is wrong though (although this does seem to
match what the clang format rules for blink do).

Anyway, fixed.

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

Basically, just think of it as namespaces never introduce indents. You might be
able to find some edge cases where this isn't true, but as a general rule of
thumb, this is safe to follow.

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

Yes, that's the chromium styleguide. The blink/webkit styleguide are explicitly
not like that (even the example in the blink styleguide has the contents of
"NestedNamespace" indented). But yeah, this definitely seems to be the most
often ignored rule in the blink styleguide. But probably not worth fixing the
blink styleguide to match reality since we hopefully won't have to deal with
separate styles for much longer anyway.

+    public:
+        explicit UrlTestImpl(url::mojom::blink::UrlTestRequest request)

[esprehn, 2016/05/25 17:06:27]

Where are things like the generated TestRequest stuff documented?

[Marijn Kruisselbrink, 2016/05/25 17:35:08]

https://www.chromium.org/developers/design-documents/mojo#TOC-Bindings seems to
document at least some of this stuff (and in particular mentions the generated
FooRequest typedef).

+            : 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++) {
+        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