Mojo C++ bindings: support mapping mojo string to WTF::String.

mojo/public/cpp/bindings/lib/wtf_string_serialization.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 "mojo/public/cpp/bindings/lib/wtf_string_serialization.h"
+
+#include <string.h>
+
+#include "base/logging.h"
+#include "third_party/WebKit/Source/wtf/text/WTFString.h"
+
+namespace WTF {
+
+size_t GetSerializedSize_(const WTF::String& input) {
+  if (input.isNull())
+    return 0;
+
+  DCHECK(input.is8Bit());

[haraken, 2016/03/01 00:40:54]

From the perspective of Blink, in common cases we don't know if a given string
is a 8-bit string or a 16-bit string. In that sense, this restriction is not
really embedder-friendly :)

Would it make sense to add conversion code from a 16-bit string to a 8-bit
string here?

[yzshen1, 2016/03/01 00:51:53]

If the receiver doesn't care whether the string was originally 16 bit or not,
then it should be doable -- the receiver always gets a 8-bit string, even if the
data is deserialized as a WTF::String.

Another choice is to require the caller of mojo interface to do the
check/conversion explicitly before passing WTF::String to mojo interfaces (which
is what I had in mind). Because according to mojom spec, mojo strings are
8-bits. The caller is responsible to use valid arguments to make calls.

WDYT? Thanks!

[haraken, 2016/03/01 01:56:46]

Elliott: Do you have any preference on this?

[esprehn, 2016/03/01 02:03:32]

wtf::String is 16 bit for many cases, the 8 bit strings are an optimization for
latin1 and ascii. The mojo 8bit strings mean something else entirely, they're
utf8, which isn't the same.

I don't think this code makes sense, you're asserting that the string is all
latin1?

[yzshen1, 2016/03/01 17:32:02]

Mojo string is 8 bit but not enforced to be utf8. (We talked about enforcing it
before but didn't do it as of now)

IMO, this CL tries to solve the problem of using mojo interfaces in blink, not
trying to change mojo spec to fit blink. (Not saying that shouldn't be
considered, but seems beyond the scope of the CL.)

So if we have a mojo interface:
interface Foo {
  SendString(string bar);
};

|bar| here is 8-bit according to mojo spec. We map |bar| to WTF::String just in
blink; the other side is free to map it to a different type, such as
mojo::String.

So when a user pass a WTF::String to a mojo interface, this string should
conform to mojo's requirement. As we mentioned above, two choices: (1) convert
it to 8-bit if it is not (question: what conversion function should I use if we
take this approach?); (2) assume it is the user's responsibility to do the
necessary conversion before making the call and [D]CHECK.

WDYT?

+  return mojo::internal::Align(sizeof(mojo::internal::String_Data) +
+                               input.length());
+}
+
+void Serialize_(const WTF::String& input,
+                mojo::internal::Buffer* buf,
+                mojo::internal::String_Data** output) {
+  if (input.isNull()) {
+    *output = nullptr;
+    return;
+  }
+
+  DCHECK(input.is8Bit());
+  mojo::internal::String_Data* result =
+      mojo::internal::String_Data::New(input.length(), buf);
+  if (result)
+    memcpy(result->storage(), input.characters8(), input.length());
+  *output = result;
+}
+
+bool Deserialize_(mojo::internal::String_Data* input,
+                  WTF::String* output,
+                  mojo::internal::SerializationContext* context) {
+  if (input) {
+    WTF::String result(input->storage(), input->size());
+    output->swap(result);
+  } else if (!output->isNull()) {
+    WTF::String result;
+    output->swap(result);
+  }
+  return true;
+}
+
+}  // namespace WTF