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

mojo/public/cpp/bindings/lib/wtf_string_serialization.cc

Index: mojo/public/cpp/bindings/lib/wtf_string_serialization.cc
diff --git a/mojo/public/cpp/bindings/lib/wtf_string_serialization.cc b/mojo/public/cpp/bindings/lib/wtf_string_serialization.cc
new file mode 100644
index 0000000000000000000000000000000000000000..96c3fec3bf510630c0626055b5a3e3d7f4317d8d
--- /dev/null
+++ b/mojo/public/cpp/bindings/lib/wtf_string_serialization.cc
@@ -0,0 +1,103 @@
+// 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 <queue>
+
+#include "base/logging.h"
+#include "third_party/WebKit/Source/wtf/text/StringUTF8Adaptor.h"
+#include "third_party/WebKit/Source/wtf/text/WTFString.h"
+
+namespace WTF {
+namespace {
+
+struct UTF8AdaptorWithPointer {
+  explicit UTF8AdaptorWithPointer(const WTF::String& input)
+      : utf8_adaptor(input), original_input(&input) {}
+
+  ~UTF8AdaptorWithPointer() {}
+
+  WTF::StringUTF8Adaptor utf8_adaptor;

[esprehn, 2016/03/04 04:14:48]

I'd rather you just stored the StringUTF8Adaptor. Note that this isn't generally
considered to be public API from webkit either. Are we sure we want WTF code in
mojo/ instead of adding a mojo directory to third_party/WebKit and keeping our
stuff there?

[yzshen1, 2016/03/04 17:28:49]

If we move the serialization code of WTF::String into WebKit, we may have a
circular dependency issue: the code depends on some internal stuff of mojo
(mojo::internal::Buffer/String_Data/SerializationContext); and mojo depends on
the WTF::String serialization code. I think it probably doesn't worth the effort
to re-arrange things to make that work.

The WTF-friendly bindings should only be used in WebKit, so
WTF::StringUTF8Adaptor technically is not exposed to the outside. :)

WDYT? Thanks!

+  // For sanity check.
+  const WTF::String* original_input;
+};
+
+class WTFStringContextImpl : public mojo::internal::WTFStringContext {
+ public:
+  WTFStringContextImpl() {}
+  ~WTFStringContextImpl() override {}
+
+  std::queue<UTF8AdaptorWithPointer>& utf8_adaptors() { return utf8_adaptors_; }
+
+ private:
+  std::queue<UTF8AdaptorWithPointer> utf8_adaptors_;

[haraken, 2016/03/04 04:04:50]

Just help me understand: Why do we need to queue the UTF8AdaptorWithPointers?

[esprehn, 2016/03/04 04:14:48]

Can we use a std::vector instead? std::deque is not especially efficient, but
maybe it's okay here.

[yzshen1, 2016/03/04 17:28:49]

Serialization consists of two passes: the first uses GetSerializedSize_() to
calculate the size; the second uses Serialize_() to do actual serialization.

Imagine we have such a struct:
struct Foo {
  string a;
  array<string> b;
  map<string, string> c;
};

When serializing Foo, we call GetSerializedSize_() for all the members (some of
them are strings) recursively to compute the total size of Foo; and then we call
Serialize_() recursively in the same order.

If a WTF::String needs to be converted to UTF8, we don't want to do that twice.
Therefore, we store a StringUTF8Adaptor in the first pass, so that we can reuse
it in the second pass.

[yzshen1, 2016/03/04 17:28:49]

I think std::queue is more efficient than std::vector in this case, because all
I need is push to the back and remove from the front.

[haraken, 2016/03/07 02:04:29]

Thanks, makes sense. Maybe worth adding a comment?

[yzshen1, 2016/03/07 18:26:47]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(WTFStringContextImpl);
+};
+
+}  // namespace
+
+size_t GetSerializedSize_(const WTF::String& input,
+                          mojo::internal::SerializationContext* context) {
+  if (input.isNull())
+    return 0;
+
+  if (!context->wtf_string_context)
+    context->wtf_string_context.reset(new WTFStringContextImpl);
+
+  auto& utf8_adaptors =
+      static_cast<WTFStringContextImpl*>(context->wtf_string_context.get())
+          ->utf8_adaptors();
+
+  utf8_adaptors.emplace(input);
+
+  return mojo::internal::Align(sizeof(mojo::internal::String_Data) +
+                               utf8_adaptors.back().utf8_adaptor.length());
+}
+
+void Serialize_(const WTF::String& input,
+                mojo::internal::Buffer* buf,
+                mojo::internal::String_Data** output,
+                mojo::internal::SerializationContext* context) {
+  if (input.isNull()) {
+    *output = nullptr;
+    return;
+  }
+
+  auto& utf8_adaptors =
+      static_cast<WTFStringContextImpl*>(context->wtf_string_context.get())
+          ->utf8_adaptors();
+
+  CHECK(!utf8_adaptors.empty());
+  CHECK_EQ(utf8_adaptors.front().original_input, &input);

[esprehn, 2016/03/04 04:14:48]

Is this really worth the overhead?

[yzshen1, 2016/03/04 17:28:49]

Here we compare the string pointers, not the string contents. So the overhead
should be negligible. I changed the type of |original_input| to uintptr_t to be
more clear.  I have also changed this to DCHECK.

This is used as a sanity check to make sure that we never mismatch
StringUTF8Adaptor and String.

+
+  const WTF::StringUTF8Adaptor& adaptor = utf8_adaptors.front().utf8_adaptor;
+
+  mojo::internal::String_Data* result =
+      mojo::internal::String_Data::New(adaptor.length(), buf);
+  if (result)
+    memcpy(result->storage(), adaptor.data(), adaptor.length());
+
+  utf8_adaptors.pop();
+
+  *output = result;
+}
+
+bool Deserialize_(mojo::internal::String_Data* input,
+                  WTF::String* output,
+                  mojo::internal::SerializationContext* context) {
+  if (input) {
+    WTF::String result = WTF::String::fromUTF8(input->storage(), input->size());
+    output->swap(result);
+  } else if (!output->isNull()) {
+    WTF::String result;
+    output->swap(result);
+  }
+  return true;
+}
+
+}  // namespace WTF