Mojo: Delete some old, unused code.

mojo/system/handle_table.h

 // Copyright 2014 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_HANDLE_TABLE_H_
 #define MOJO_SYSTEM_HANDLE_TABLE_H_
 
 #include <utility>
 #include <vector>
 
@@ skipping 83 matching lines @@
   void RemoveBusyHandles(const MojoHandle* handles, uint32_t num_handles);
 
   // Restores the given handles, which must all be present and which should have
   // previously been marked busy by |MarkBusyAndStartTransport()|, to a non-busy
   // state.
   void RestoreBusyHandles(const MojoHandle* handles, uint32_t num_handles);
 
  private:
   friend bool internal::ShutdownCheckNoLeaks(Core*);
 
+  // The |busy| member is used only to deal with functions (in particular
+  // |Core::WriteMessage()|) that want to hold on to a dispatcher and later
+  // remove it from the handle table, without holding on to the handle table
+  // lock.
+  //
+  // For example, if |Core::WriteMessage()| is called with a handle to be sent,
+  // (under the handle table lock) it must first check that that handle is not
+  // busy (if it is busy, then it fails with |MOJO_RESULT_BUSY|) and then marks
+  // it as busy. To avoid deadlock, it should also try to acquire the locks for
+  // all the dispatchers for the handles that it is sending (and fail with
+  // |MOJO_RESULT_BUSY| if the attempt fails). At this point, it can release the
+  // handle table lock.
+  //
+  // If |Core::Close()| is simultaneously called on that handle, it too checks
+  // if the handle is marked busy. If it is, it fails (with |MOJO_RESULT_BUSY|).
+  // This prevents |Core::WriteMessage()| from sending a handle that has been
+  // closed (or learning about this too late).
   struct Entry {
     Entry();
     explicit Entry(const scoped_refptr<Dispatcher>& dispatcher);
     ~Entry();
 
     scoped_refptr<Dispatcher> dispatcher;
     bool busy;
   };
   typedef base::hash_map<MojoHandle, Entry> HandleToEntryMap;
 
   // Adds the given dispatcher to the handle table, not doing any size checks.
   MojoHandle AddDispatcherNoSizeCheck(
       const scoped_refptr<Dispatcher>& dispatcher);
 
   HandleToEntryMap handle_to_entry_map_;
   MojoHandle next_handle_;  // Invariant: never |MOJO_HANDLE_INVALID|.
 
   DISALLOW_COPY_AND_ASSIGN(HandleTable);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_HANDLE_TABLE_H_