Add mojo struct traits for GURL so that it can be sent over mojoms.

url/mojo/url_gurl_struct_traits_unittest.cc

+// 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 <utility>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/mojo/url_test.mojom.h"
+
+namespace url {
+
+class UrlTestImpl : public mojom::UrlTest {
+ public:
+  explicit UrlTestImpl(mojo::InterfaceRequest<url::mojom::UrlTest> request)
+      : binding_(this, std::move(request)) {
+  }
+
+  // UrlTest:
+  void Bounce(const GURL& in, const BounceCallback& callback) override {
+    callback.Run(in);
+  }
+
+ private:
+  mojo::Binding<UrlTest> binding_;
+};
+
+// Mojo version of chrome IPC test in
+// content/common/common_param_traits_unittest.cc
+TEST(MojoUrlGURLStructTraitsTest, Basic) {
+  base::MessageLoop message_loop;
+
+  mojom::UrlTestPtr proxy;
+  UrlTestImpl impl(GetProxy(&proxy));
+
+  const char* serialize_cases[] = {
+    "http://www.google.com/",
+    "http://user:pass@host.com:888/foo;bar?baz#nop",
+  };
+
+  for (size_t i = 0; i < arraysize(serialize_cases); i++) {
+    GURL input(serialize_cases[i]);
+    GURL output;
+    EXPECT_TRUE(proxy->Bounce(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.possibly_invalid_spec(), output.possibly_invalid_spec());
+    EXPECT_EQ(input.is_valid(), output.is_valid());
+    EXPECT_EQ(input.scheme(), output.scheme());
+    EXPECT_EQ(input.username(), output.username());
+    EXPECT_EQ(input.password(), output.password());
+    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.ref(), output.ref());
+  }
+
+  // Test an excessively long GURL.
+  {
+    const std::string url = std::string("http://example.org/").append(
+        mojo::kMaxUrlChars + 1, 'a');
+    GURL input(url.c_str());
+    GURL output;
+    EXPECT_TRUE(proxy->Bounce(input, &output));

[yzshen1, 2016/03/03 21:47:56]

Hmm.. this test case should result in message pipe disconnection because of the
illegal input, right?
In that case, the returning value should be false, instead of returning true and
receive a connection error later.

I will fix the sync call behavior. (No need to block this CL on that, I will
update this test after the fix.)
Sorry. :)

[jam, 2016/03/03 21:49:47]

thanks for noticing that, yes that'd be great.

[yzshen1, 2016/03/09 00:01:52]

I have looked into this issue and found that the sync call returns success
because the invalid input doesn't reach the the message pipe. Before sending,
the bindings call StructTraits::url() to serialize the input. This method
returns an empty string for any invalid input. Therefore, the data passed over
the message pipe is actually valid. (So the sync call logic is working as
expected in this case.)

It depends on which behavior we think that makes more sense. The current
StructTraits will automatically serialize invalid input as empty string. If we
want to disconnect the message pipe on invalid input instead, we need to remove
the validation code from StructTraits::url().

+    EXPECT_TRUE(output.is_empty());
+  }
+}
+
+}  // namespace url