Mojo: Add thread assertions to various private Channel methods.

mojo/system/channel.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/system/channel.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 257 matching lines @@
 }
 
 Channel::~Channel() {
   // The channel should have been shut down first.
   DCHECK(!is_running_);
 }
 
 void Channel::OnReadMessage(
     const MessageInTransit::View& message_view,
     embedder::ScopedPlatformHandleVectorPtr platform_handles) {
+  DCHECK(creation_thread_checker_.CalledOnValidThread());
+
   switch (message_view.type()) {
     case MessageInTransit::kTypeMessagePipeEndpoint:
     case MessageInTransit::kTypeMessagePipe:
       OnReadMessageForDownstream(message_view, platform_handles.Pass());
       break;
     case MessageInTransit::kTypeChannel:
       OnReadMessageForChannel(message_view, platform_handles.Pass());
       break;
     default:
       HandleRemoteError(
           base::StringPrintf("Received message of invalid type %u",
                              static_cast<unsigned>(message_view.type())));
       break;
   }
 }
 
 void Channel::OnError(Error error) {
+  DCHECK(creation_thread_checker_.CalledOnValidThread());
+
   switch (error) {
     case ERROR_READ_SHUTDOWN:
       // The other side was cleanly closed, so this isn't actually an error.
       DVLOG(1) << "RawChannel read error (shutdown)";
       break;
     case ERROR_READ_BROKEN: {
       base::AutoLock locker(lock_);
       LOG_IF(ERROR, !is_shutting_down_)
           << "RawChannel read error (connection broken)";
       break;
@@ skipping 11 matching lines @@
       // normal operation (but maybe the other side crashed).
       LOG(WARNING) << "RawChannel write error";
       break;
   }
   Shutdown();
 }
 
 void Channel::OnReadMessageForDownstream(
     const MessageInTransit::View& message_view,
     embedder::ScopedPlatformHandleVectorPtr platform_handles) {
+  DCHECK(creation_thread_checker_.CalledOnValidThread());
   DCHECK(message_view.type() == MessageInTransit::kTypeMessagePipeEndpoint ||
          message_view.type() == MessageInTransit::kTypeMessagePipe);
 
   MessageInTransit::EndpointId local_id = message_view.destination_id();
   if (local_id == MessageInTransit::kInvalidEndpointId) {
     HandleRemoteError("Received message with no destination ID");
     return;
   }
 
   ChannelEndpoint::State state = ChannelEndpoint::STATE_NORMAL;
@@ skipping 59 matching lines @@
         "Failed to enqueue message to local ID %u (result %d)",
         static_cast<unsigned>(local_id),
         static_cast<int>(result)));
     return;
   }
 }
 
 void Channel::OnReadMessageForChannel(
     const MessageInTransit::View& message_view,
     embedder::ScopedPlatformHandleVectorPtr platform_handles) {
+  DCHECK(creation_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(message_view.type(), MessageInTransit::kTypeChannel);
 
   // Currently, no channel messages take platform handles.
   if (platform_handles) {
     HandleRemoteError(
         "Received invalid channel message (has platform handles)");
     NOTREACHED();
     return;
   }
 
@@ skipping 31 matching lines @@
     default:
       HandleRemoteError("Received invalid channel message");
       NOTREACHED();
       break;
   }
 }
 
 bool Channel::RemoveMessagePipeEndpoint(
     MessageInTransit::EndpointId local_id,
     MessageInTransit::EndpointId remote_id) {
+  DCHECK(creation_thread_checker_.CalledOnValidThread());
+
   scoped_refptr<MessagePipe> message_pipe;
   unsigned port;
   {
     base::AutoLock locker(lock_);
 
     IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
     if (it == local_id_to_endpoint_map_.end()) {
       DVLOG(2) << "Remove message pipe error: not found";
       return false;
     }
@@ skipping 53 matching lines @@
   // TODO(vtl): Is this how we really want to handle this?
   // Sometimes we'll want to propagate the error back to the message pipe
   // (endpoint), and notify it that the remote is (effectively) closed.
   // Sometimes we'll want to kill the channel (and notify all the endpoints that
   // their remotes are dead.
   LOG(WARNING) << error_message;
 }
 
 }  // namespace system
 }  // namespace mojo