Mojo: Add RawChannel tests for calling Shutdown() from OnReadMessage()/OnFatalError().

mojo/system/raw_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_RAW_CHANNEL_H_
 #define MOJO_SYSTEM_RAW_CHANNEL_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 41 matching lines @@
       FATAL_ERROR_FAILED_READ,
       FATAL_ERROR_FAILED_WRITE
     };
 
     // Called when a message is read. This may call |Shutdown()| (on the
     // |RawChannel|), but must not destroy it.
     virtual void OnReadMessage(const MessageInTransit::View& message_view) = 0;
 
     // Called when there's a fatal error, which leads to the channel no longer
     // being viable. This may call |Shutdown()| (on the |RawChannel()|), but
-    // must now destroy it.
+    // must not destroy it.
     //
     // For each raw channel, at most one |FATAL_ERROR_FAILED_READ| and at most
     // one |FATAL_ERROR_FAILED_WRITE| notification will be issued (both may be
     // issued). After a |OnFatalError(FATAL_ERROR_FAILED_READ)|, there will be
     // no further calls to |OnReadMessage()|.
     virtual void OnFatalError(FatalError fatal_error) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
   // Static factory method. |handle| should be a handle to a
   // (platform-appropriate) bidirectional communication channel (e.g., a socket
   // on POSIX, a named pipe on Windows).
   static scoped_ptr<RawChannel> Create(embedder::ScopedPlatformHandle handle);
 
   // This must be called (on an I/O thread) before this object is used. Does
   // *not* take ownership of |delegate|. Both the I/O thread and |delegate| must
-  // remain alive for the lifetime of this object. Returns true on success. On
+  // remain alive until |Shutdown()| is called (unless this fails); |delegate|
+  // will no longer be used after |Shutdown()|. Returns true on success. On
   // failure, |Shutdown()| should *not* be called.
   bool Init(Delegate* delegate);
 
   // This must be called (on the I/O thread) before this object is destroyed.
   void Shutdown();
 
   // Writes the given message (or schedules it to be written). This is
   // thread-safe. Returns true on success.
   bool WriteMessage(scoped_ptr<MessageInTransit> message);
 
@@ skipping 100 matching lines @@
   // - if the method returns IO_PENDING, |OnWriteCompleted()| will be called on
   //   the I/O thread to report the result, unless |Shutdown()| is called.
   virtual IOResult WriteNoLock(size_t* bytes_written) = 0;
   // Similar to |WriteNoLock()|, except that the implementing subclass must also
   // guarantee that the method doesn't succeed synchronously, i.e., it only
   // returns IO_FAILED or IO_PENDING.
   virtual IOResult ScheduleWriteNoLock() = 0;
 
   // Must be called on the I/O thread WITHOUT |write_lock_| held.
   virtual bool OnInit() = 0;
-  // On shutdown, passes the ownership of the buffers to subclasses, who may
-  // want to preserve them if there are pending read/write.
-  // Must be called on the I/O thread under |write_lock_|.
+  // On shutdown, passes the ownership of the buffers to subclasses, which may
+  // want to preserve them if there are pending read/write. Must be called on
+  // the I/O thread under |write_lock_|.
   virtual void OnShutdownNoLock(
       scoped_ptr<ReadBuffer> read_buffer,
       scoped_ptr<WriteBuffer> write_buffer) = 0;
 
   // Must be called on the I/O thread WITHOUT |write_lock_| held.
   void OnReadCompleted(bool result, size_t bytes_read);
   // Must be called on the I/O thread WITHOUT |write_lock_| held.
   void OnWriteCompleted(bool result, size_t bytes_written);
 
  private:
   // Calls |delegate_->OnFatalError(fatal_error)|. Must be called on the I/O
   // thread WITHOUT |write_lock_| held.
   void CallOnFatalError(Delegate::FatalError fatal_error);
 
   // If |result| is true, updates the write buffer and schedules a write
   // operation to run later if there are more contents to write. If |result| is
   // false or any error occurs during the method execution, cancels pending
   // writes and returns false.
   // Must be called only if |write_stopped_| is false and under |write_lock_|.
   bool OnWriteCompletedNoLock(bool result, size_t bytes_written);
 
   // Set in |Init()| and never changed (hence usable on any thread without
   // locking):
-  Delegate* delegate_;
   base::MessageLoopForIO* message_loop_for_io_;
 
   // Only used on the I/O thread:
+  Delegate* delegate_;
   bool read_stopped_;
   scoped_ptr<ReadBuffer> read_buffer_;
 
   base::Lock write_lock_;  // Protects the following members.
   bool write_stopped_;
   scoped_ptr<WriteBuffer> write_buffer_;
 
   // This is used for posting tasks from write threads to the I/O thread. It
   // must only be accessed under |write_lock_|. The weak pointers it produces
   // are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_RAW_CHANNEL_H_