Show the callstack that a nontransferable message pipe was first used if it's erroneously sent later

mojo/edk/system/message_pipe_dispatcher.cc

 // Copyright 2015 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/edk/system/message_pipe_dispatcher.h"
 
 #include "base/bind.h"
+#include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_handle_utils.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/broker.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/options_validation.h"
@@ skipping 416 matching lines @@
 void MessagePipeDispatcher::CloseImplNoLock() {
   lock().AssertAcquired();
   internal::g_io_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&MessagePipeDispatcher::CloseOnIO, this));
 }
 
 void MessagePipeDispatcher::SerializeInternal() {
   serialized_ = true;
   if (!transferable_) {
     CHECK(non_transferable_state_ == WAITING_FOR_READ_OR_WRITE)
-        << "Non transferable message pipe being sent after read/write. "
+        << "Non transferable message pipe being sent after read/write/waited. "
         << "MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_TRANSFERABLE must be used if "
-        << "the pipe can be sent after it's read or written.";
+        << "the pipe can be sent after it's read or written. This message pipe "
+        << "was previously bound at:\n"
+        << non_transferable_bound_stack_->ToString();
+
     non_transferable_state_ = SERIALISED;
     return;
   }
 
   // We need to stop watching handle immediately, even though not on IO thread,
   // so that other messages aren't read after this.
   std::vector<int> serialized_read_fds, serialized_write_fds;
   if (channel_) {
     bool write_error = false;
 
@@ skipping 147 matching lines @@
 MojoResult MessagePipeDispatcher::ReadMessageImplNoLock(
     void* bytes,
     uint32_t* num_bytes,
     DispatcherVector* dispatchers,
     uint32_t* num_dispatchers,
     MojoReadMessageFlags flags) {
   lock().AssertAcquired();
   if (channel_) {
     channel_->EnsureLazyInitialized();
   } else if (!transferable_) {
-      if (non_transferable_state_ == WAITING_FOR_READ_OR_WRITE) {
-        RequestNontransferableChannel();
-        return MOJO_RESULT_SHOULD_WAIT;
-      } else if (non_transferable_state_ == CONNECT_CALLED) {
-        return MOJO_RESULT_SHOULD_WAIT;
-      }
+    if (non_transferable_state_ == WAITING_FOR_READ_OR_WRITE) {
+      RequestNontransferableChannel();
+      return MOJO_RESULT_SHOULD_WAIT;
+    } else if (non_transferable_state_ == CONNECT_CALLED) {
+      return MOJO_RESULT_SHOULD_WAIT;
+    }
   }
 
   DCHECK(!dispatchers || dispatchers->empty());
 
   const uint32_t max_bytes = !num_bytes ? 0 : *num_bytes;
   const uint32_t max_num_dispatchers = num_dispatchers ? *num_dispatchers : 0;
 
   if (message_queue_.IsEmpty())
     return channel_ ? MOJO_RESULT_SHOULD_WAIT : MOJO_RESULT_FAILED_PRECONDITION;
 
@@ skipping 346 matching lines @@
   }
   message->SetDispatchers(dispatchers.Pass());
   return MOJO_RESULT_OK;
 }
 
 void MessagePipeDispatcher::RequestNontransferableChannel() {
   lock().AssertAcquired();
   CHECK(!transferable_);
   CHECK_EQ(non_transferable_state_, WAITING_FOR_READ_OR_WRITE);
   non_transferable_state_ = CONNECT_CALLED;
+#if !defined(OFFICIAL_BUILD)
+  non_transferable_bound_stack_.reset(new base::debug::StackTrace);
+#endif
 
   // PostTask since the broker can call us back synchronously.
   internal::g_io_thread_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&Broker::ConnectMessagePipe,
                  base::Unretained(internal::g_broker), pipe_id_,
                  base::Unretained(this)));
 }
 
 }  // namespace edk
 }  // namespace mojo