Mojo: Add thread assertions to various private Channel methods.

mojo/system/channel.h

 // 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.
 
 #ifndef MOJO_SYSTEM_CHANNEL_H_
 #define MOJO_SYSTEM_CHANNEL_H_
 
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
@@ skipping 17 matching lines @@
 namespace embedder {
 class PlatformSupport;
 }
 
 namespace system {
 
 // This class is mostly thread-safe. It must be created on an I/O thread.
 // |Init()| must be called on that same thread before it becomes thread-safe (in
 // particular, before references are given to any other thread) and |Shutdown()|
 // must be called on that same thread before destruction. Its public methods are
-// otherwise thread-safe. It may be destroyed on any thread, in the sense that
-// the last reference to it may be released on any thread, with the proviso that
+// otherwise thread-safe. (Many private methods are restricted to the creation
+// thread.) It may be destroyed on any thread, in the sense that the last
+// reference to it may be released on any thread, with the proviso that
 // |Shutdown()| must have been called first (so the pattern is that a "main"
 // reference is kept on its creation thread and is released after |Shutdown()|
 // is called, but other threads may have temporarily "dangling" references).
 //
 // Note that |MessagePipe| calls into |Channel| and the former's |lock_| must be
 // acquired before the latter's. When |Channel| wants to call into a
 // |MessagePipe|, it must obtain a reference to the |MessagePipe| (from
 // |local_id_to_endpoint_info_map_|) under |Channel::lock_| and then release the
 // lock.
 //
@@ skipping 79 matching lines @@
   size_t GetSerializedPlatformHandleSize() const;
 
   embedder::PlatformSupport* platform_support() const {
     return platform_support_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<Channel>;
   virtual ~Channel();
 
-  // |RawChannel::Delegate| implementation:
+  // |RawChannel::Delegate| implementation (only called on the creation thread):
   virtual void OnReadMessage(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles) OVERRIDE;
   virtual void OnError(Error error) OVERRIDE;
 
-  // Helpers for |OnReadMessage|:
+  // Helpers for |OnReadMessage| (only called on the creation thread):
   void OnReadMessageForDownstream(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles);
   void OnReadMessageForChannel(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles);
 
   // Removes the message pipe endpoint with the given local ID, which must exist
   // and be a zombie, and given remote ID. Returns false on failure, in
-  // particular if no message pipe with |local_id| is attached.
+  // particular if no message pipe with |local_id| is attached. Only called on
+  // the creation thread.
   bool RemoveMessagePipeEndpoint(MessageInTransit::EndpointId local_id,
                                  MessageInTransit::EndpointId remote_id);
 
-  // Handles errors (e.g., invalid messages) from the remote side.
+  // Handles errors (e.g., invalid messages) from the remote side. Callable from
+  // any thread.
   void HandleRemoteError(const base::StringPiece& error_message);
-  // Handles internal errors/failures from the local side.
+  // Handles internal errors/failures from the local side. Callable from any
+  // thread.
   void HandleLocalError(const base::StringPiece& error_message);
 
   // Helper to send channel control messages. Returns true on success. Should be
-  // called *without* |lock_| held.
+  // called *without* |lock_| held. Callable from any thread.
   bool SendControlMessage(MessageInTransit::Subtype subtype,
                           MessageInTransit::EndpointId source_id,
                           MessageInTransit::EndpointId destination_id);
 
   base::ThreadChecker creation_thread_checker_;
 
   embedder::PlatformSupport* const platform_support_;
 
   // Note: |MessagePipe|s MUST NOT be used under |lock_|. I.e., |lock_| can only
   // be acquired after |MessagePipe::lock_|, never before. Thus to call into a
@@ skipping 13 matching lines @@
   // be checked for existence before use.
   MessageInTransit::EndpointId next_local_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_CHANNEL_H_