Mojo: Add the ability to notify a Mojo Channel that it's going to be destroyed soon.

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 49 matching lines @@
   // This must be called on the creation thread before any other methods are
   // called, and before references to this object are given to any other
   // threads. |raw_channel| should be uninitialized. Returns true on success. On
   // failure, no other methods should be called (including |Shutdown()|).
   bool Init(scoped_ptr<RawChannel> raw_channel);
 
   // This must be called on the creation thread before destruction (which can
   // happen on any thread).
   void Shutdown();
 
+  // Signals that |Shutdown()| will be called soon (this may be called from any
+  // thread, unlike |Shutdown()|). Warnings will be issued if, e.g., messages
+  // are written after this is called; other warnings may be suppressed. (This
+  // may be called multiple times, or not at all.)
+  void WillShutdownSoon();
+
   // Attaches the given message pipe/port's endpoint (which must be a
   // |ProxyMessagePipeEndpoint|) to this channel. This assigns it a local ID,
   // which it returns. The first message pipe endpoint attached will always have
   // |kBootstrapEndpointId| as its local ID. (For bootstrapping, this occurs on
   // both sides, so one should use |kBootstrapEndpointId| for the remote ID for
   // the first message pipe across a channel.) Returns |kInvalidEndpointId| on
   // failure.
   // TODO(vtl): Maybe limit the number of attached message pipes.
   MessageInTransit::EndpointId AttachMessagePipeEndpoint(
       scoped_refptr<MessagePipe> message_pipe,
@@ skipping 85 matching lines @@
   void HandleRemoteError(const base::StringPiece& error_message);
   // Handles internal errors/failures from the local side.
   void HandleLocalError(const base::StringPiece& error_message);
 
   // Helper to send channel control messages. Returns true on success. Should be
   // called *without* |lock_| held.
   bool SendControlMessage(MessageInTransit::Subtype subtype,
                           MessageInTransit::EndpointId source_id,
                           MessageInTransit::EndpointId destination_id);
 
-  bool is_running_no_lock() const { return is_running_; }
-
   base::ThreadChecker creation_thread_checker_;
 
   // 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
   // |MessagePipe|, a reference should be acquired from
   // |local_id_to_endpoint_info_map_| under |lock_| (e.g., by copying the
   // |EndpointInfo|) and then the lock released.
   base::Lock lock_;  // Protects the members below.
 
   scoped_ptr<RawChannel> raw_channel_;
   bool is_running_;
+  // Set when |WillShutdownSoon()| is called.
+  bool is_shutting_down_;
 
   typedef base::hash_map<MessageInTransit::EndpointId, EndpointInfo>
       IdToEndpointInfoMap;
   IdToEndpointInfoMap local_id_to_endpoint_info_map_;
   // The next local ID to try (when allocating new local IDs). Note: It should
   // 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_