Mojo: Add the ability to hook up a channel to the embedder API.

mojo/system/core_impl.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_IMPL_H_
 #define MOJO_SYSTEM_CORE_IMPL_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "mojo/public/system/core_private.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
 
-namespace embedder {
-void Init();  // So it can be friended.
-}
-
 namespace system {
 
 class CoreImpl;
 class Dispatcher;
 
-namespace test {
-class CoreTestBase;
-}
-
 // |CoreImpl| is a singleton object that implements the Mojo system calls. All
 // public methods are thread-safe.
 class MOJO_SYSTEM_IMPL_EXPORT CoreImpl : public Core {
  public:
-  static void Init();
+  // These methods are only to be used by via the embedder API.
+  CoreImpl();
+  virtual ~CoreImpl();
+  MojoHandle AddDispatcher(const scoped_refptr<Dispatcher>& dispatcher);
 
   // |CorePrivate| implementation:
   virtual MojoTimeTicks GetTimeTicksNow() OVERRIDE;
   virtual MojoResult Close(MojoHandle handle) OVERRIDE;
   virtual MojoResult Wait(MojoHandle handle,
                           MojoWaitFlags flags,
                           MojoDeadline deadline) OVERRIDE;
   virtual MojoResult WaitMany(const MojoHandle* handles,
                               const MojoWaitFlags* flags,
                               uint32_t num_handles,
@@ skipping 32 matching lines @@
                               uint32_t* num_bytes,
                               MojoReadDataFlags flags) OVERRIDE;
   virtual MojoResult BeginReadData(MojoHandle data_pipe_consumer_handle,
                                    const void** buffer,
                                    uint32_t* buffer_num_bytes,
                                    MojoReadDataFlags flags) OVERRIDE;
   virtual MojoResult EndReadData(MojoHandle data_pipe_consumer_handle,
                                  uint32_t num_bytes_read) OVERRIDE;
 
  private:
-  friend void embedder::Init();
-  friend class test::CoreTestBase;
-
   // 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
@@ skipping 15 matching lines @@
   struct HandleTableEntry {
     HandleTableEntry();
     explicit HandleTableEntry(const scoped_refptr<Dispatcher>& dispatcher);
     ~HandleTableEntry();
 
     scoped_refptr<Dispatcher> dispatcher;
     bool busy;
   };
   typedef base::hash_map<MojoHandle, HandleTableEntry> HandleTableMap;
 
-  CoreImpl();
-  virtual ~CoreImpl();
-
   // Looks up the dispatcher for the given handle. Returns null if the handle is
   // invalid.
   scoped_refptr<Dispatcher> GetDispatcher(MojoHandle handle);
 
   // Assigns a new handle for the given dispatcher (which must be valid);
   // returns |MOJO_HANDLE_INVALID| on failure (due to hitting resource limits).
   // Must be called under |handle_table_lock_|.
   MojoHandle AddDispatcherNoLock(const scoped_refptr<Dispatcher>& dispatcher);
 
   // Internal implementation of |Wait()| and |WaitMany()|; doesn't do basic
@@ skipping 14 matching lines @@
   // ---------------------------------------------------------------------------
 
   DISALLOW_COPY_AND_ASSIGN(CoreImpl);
 };
 
 }  // namespace system
 
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_CORE_IMPL_H_