Mojo: Move the handle table details out of CoreImpl into its own class.

mojo/system/dispatcher.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_DISPATCHER_H_
 #define MOJO_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "mojo/public/c/system/core.h"
 // TODO(vtl): We need this since we can't forward declare
 // |RawSharedBuffer::Mapping|. Maybe fix this.
 #include "mojo/system/raw_shared_buffer.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
 namespace system {
 
 class Channel;
 class CoreImpl;
 class Dispatcher;
 class DispatcherTransport;
+class HandleTable;
 class LocalMessagePipeEndpoint;
 class MessageInTransit;
 class ProxyMessagePipeEndpoint;
 class Waiter;
 
 namespace test {
 
 // Test helper. We need to declare it here so we can friend it.
 MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport DispatcherTryStartTransport(
     Dispatcher* dispatcher);
@@ skipping 79 matching lines @@
   //  - |MOJO_RESULT_ALREADY_EXISTS| if |flags| is already satisfied;
   //  - |MOJO_RESULT_INVALID_ARGUMENT| if the dispatcher has been closed; and
   //  - |MOJO_RESULT_FAILED_PRECONDITION| if it is not (or no longer) possible
   //    that |flags| will ever be satisfied.
   MojoResult AddWaiter(Waiter* waiter,
                        MojoWaitFlags flags,
                        MojoResult wake_result);
   void RemoveWaiter(Waiter* waiter);
 
   // A dispatcher must be put into a special state in order to be sent across a
-  // message pipe. Outside of tests, only |CoreImplAccess| is allowed to do
+  // message pipe. Outside of tests, only |HandleTableAccess| is allowed to do
   // this, since there are requirements on the handle table (see below).
   //
   // In this special state, only a restricted set of operations is allowed.
   // These are the ones available as |DispatcherTransport| methods. Other
   // |Dispatcher| methods must not be called until |DispatcherTransport::End()|
   // has been called.
-  class CoreImplAccess {
+  class HandleTableAccess {
    private:
     friend class CoreImpl;
+    friend class HandleTable;
     // Tests also need this, to avoid needing |CoreImpl|.
     friend DispatcherTransport test::DispatcherTryStartTransport(Dispatcher*);
 
     // This must be called under the handle table lock and only if the handle
     // table entry is not marked busy. The caller must maintain a reference to
     // |dispatcher| until |DispatcherTransport::End()| is called.
     static DispatcherTransport TryStartTransport(Dispatcher* dispatcher);
   };
 
   // A |MessageInTransit| may serialize dispatchers that are attached to it to a
@@ skipping 144 matching lines @@
 
   // This protects the following members as well as any state added by
   // subclasses.
   mutable base::Lock lock_;
   bool is_closed_;
 
   DISALLOW_COPY_AND_ASSIGN(Dispatcher);
 };
 
 // Wrapper around a |Dispatcher| pointer, while it's being processed to be
-// passed in a message pipe. See the comment about |Dispatcher::CoreImplAccess|
-// for more details.
+// passed in a message pipe. See the comment about
+// |Dispatcher::HandleTableAccess| for more details.
 //
 // Note: This class is deliberately "thin" -- no more expensive than a
 // |Dispatcher*|.
 class MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport {
  public:
   DispatcherTransport() : dispatcher_(NULL) {}
 
   void End();
 
   Dispatcher::Type GetType() const { return dispatcher_->GetType(); }
   bool IsBusy() const { return dispatcher_->IsBusyNoLock(); }
   void Close() { dispatcher_->CloseNoLock(); }
   scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndClose() {
     return dispatcher_->CreateEquivalentDispatcherAndCloseNoLock();
   }
 
   bool is_valid() const { return !!dispatcher_; }
 
  protected:
   Dispatcher* dispatcher() { return dispatcher_; }
 
  private:
-  friend class Dispatcher::CoreImplAccess;
+  friend class Dispatcher::HandleTableAccess;
 
   explicit DispatcherTransport(Dispatcher* dispatcher)
       : dispatcher_(dispatcher) {}
 
   Dispatcher* dispatcher_;
 
   // Copy and assign allowed.
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_DISPATCHER_H_