Mojo: Delete some old, unused code.

mojo/system/core.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_CORE_H_
 #define MOJO_SYSTEM_CORE_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
@@ skipping 75 matching lines @@
       MojoHandle* new_buffer_handle);
   MojoResult MapBuffer(MojoHandle buffer_handle,
                        uint64_t offset,
                        uint64_t num_bytes,
                        void** buffer,
                        MojoMapBufferFlags flags);
   MojoResult UnmapBuffer(void* buffer);
 
  private:
   friend bool internal::ShutdownCheckNoLeaks(Core*);
-  // The |busy| member is used only to deal with functions (in particular
-  // |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 |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 |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 |WriteMessage()| from sending a handle that has been closed (or
-  // learning about this too late).
-  struct HandleTableEntry {
-    HandleTableEntry();
-    explicit HandleTableEntry(const scoped_refptr<Dispatcher>& dispatcher);
-    ~HandleTableEntry();
-
-    scoped_refptr<Dispatcher> dispatcher;
-    bool busy;
-  };
-  typedef base::hash_map<MojoHandle, HandleTableEntry> HandleTableMap;
 
   // Looks up the dispatcher for the given handle. Returns null if the handle is
   // invalid.
   scoped_refptr<Dispatcher> GetDispatcher(MojoHandle handle);
 
   // Internal implementation of |Wait()| and |WaitMany()|; doesn't do basic
   // validation of arguments.
   MojoResult WaitManyInternal(const MojoHandle* handles,
                               const MojoWaitFlags* flags,
                               uint32_t num_handles,
@@ skipping 11 matching lines @@
 
   // ---------------------------------------------------------------------------
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_CORE_H_