Mojo C++ Bindings: Add helpers for bad message reporting

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

 // Copyright 2013 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/message.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <utility>
 
+#include "base/bind.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/thread_local.h"
 
 namespace mojo {
 
+namespace {
+
+base::LazyInstance<base::ThreadLocalPointer<internal::MessageDispatchContext>>
+    g_tls_message_dispatch_context = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<base::ThreadLocalPointer<SyncMessageResponseContext>>
+    g_tls_sync_response_context = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
 Message::Message() {
 }
 
 Message::~Message() {
   CloseHandles();
 }
 
 void Message::Initialize(size_t capacity, bool zero_initialized) {
   DCHECK(!buffer_);
   buffer_.reset(new internal::MessageBuffer(capacity, zero_initialized));
@@ skipping 55 matching lines @@
 }
 
 void Message::CloseHandles() {
   for (std::vector<Handle>::iterator it = handles_.begin();
        it != handles_.end(); ++it) {
     if (it->is_valid())
       CloseRaw(*it);
   }
 }
 
+SyncMessageResponseContext::SyncMessageResponseContext()
+    : outer_context_(current()) {
+  g_tls_sync_response_context.Get().Set(this);
+}
+
+SyncMessageResponseContext::~SyncMessageResponseContext() {
+  DCHECK_EQ(current(), this);
+  g_tls_sync_response_context.Get().Set(outer_context_);
+}
+
+// static
+SyncMessageResponseContext* SyncMessageResponseContext::current() {
+  return g_tls_sync_response_context.Get().Get();
+}
+
+void SyncMessageResponseContext::ReportBadMessage(const std::string& error) {
+  response_.NotifyBadMessage(error);
+}
+
+ReportBadMessageCallback SyncMessageResponseContext::TakeBadMessageCallback() {
+  std::unique_ptr<Message> new_message(new Message);
+  response_.MoveTo(new_message.get());
+  return base::Bind(&Message::NotifyBadMessage,
+                    base::Owned(new_message.release()));
+}
+
 MojoResult ReadMessage(MessagePipeHandle handle, Message* message) {
   MojoResult rv;
 
   std::vector<Handle> handles;
   ScopedMessageHandle mojo_message;
   uint32_t num_bytes = 0, num_handles = 0;
   rv = ReadMessageNew(handle,
                       &mojo_message,
                       &num_bytes,
                       nullptr,
@@ skipping 11 matching lines @@
   }
 
   if (rv != MOJO_RESULT_OK)
     return rv;
 
   message->InitializeFromMojoMessage(
       std::move(mojo_message), num_bytes, &handles);
   return MOJO_RESULT_OK;
 }
 
+void ReportBadMessage(const std::string& error) {
+  internal::MessageDispatchContext::current()->message()

[yzshen1, 2016/08/03 17:10:56]

Does it make sense to check whether we have a MessageDispatchContext before
dereferencing it? (here and below)

[Ken Rockot(use gerrit already), 2016/08/03 19:13:25]

Done. We should always have one, so I've made it a DCHECK

+      ->NotifyBadMessage(error);
+}
+
+ReportBadMessageCallback TakeBadMessageCallback() {
+  std::unique_ptr<Message> new_message(new Message);

[yzshen1, 2016/08/03 17:10:56]

After taking the message, if someone tries to report bad message again, it will
crash in Message::NotifyBadMessage().

Maybe we could consider:
- making it a no-op; or
- making it share state with the ReportBadMessageCallback. (This enables
creating multiple callbacks too. But it may be a little overkill.)

WDYT?

[Ken Rockot(use gerrit already), 2016/08/03 19:13:25]

Done - Callback is lazily created and takes ownership of the Message.
ReportBadMessage uses the callback.

+  internal::MessageDispatchContext::current()->message()
+      ->MoveTo(new_message.get());
+  return base::Bind(&Message::NotifyBadMessage,
+                    base::Owned(new_message.release()));
+}
+
+namespace internal {
+
+MessageDispatchContext::MessageDispatchContext(Message* message)
+    : outer_context_(current()), message_(message) {
+  g_tls_message_dispatch_context.Get().Set(this);
+}
+
+MessageDispatchContext::~MessageDispatchContext() {
+  DCHECK_EQ(current(), this);
+  g_tls_message_dispatch_context.Get().Set(outer_context_);
+}
+
+// static
+MessageDispatchContext* MessageDispatchContext::current() {
+  return g_tls_message_dispatch_context.Get().Get();
+}
+
+// static
+void SyncMessageResponseSetup::SetCurrentSyncResponseMessage(Message* message) {
+  SyncMessageResponseContext* context = SyncMessageResponseContext::current();
+  if (context)
+    message->MoveTo(&context->response_);
+}
+
+}  // namespace internal
+
 }  // namespace mojo