Split mojo_system dylib into public and private

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.h"
+#include "mojo/public/system/core_private.h"
+#include "mojo/system/system_impl_export.h"
 
 namespace mojo {
 namespace system {
 
 class CoreImpl;
 class Dispatcher;
 
 namespace test {
 class CoreTestBase;
 }
 
 // |CoreImpl| is a singleton object that implements the Mojo system calls. With
 // the (obvious) exception of |Init()|, which must be called first (and the call
 // completed) before making any other calls, all the public methods are
 // thread-safe.
-class MOJO_SYSTEM_EXPORT CoreImpl {
+class MOJO_SYSTEM_IMPL_EXPORT CoreImpl : public Core {
  public:
   static void Init();
 
-  static CoreImpl* Get() {
-    return singleton_;
-  }
+  virtual MojoResult Close(MojoHandle handle) OVERRIDE;

[viettrungluu, 2013/12/09 19:25:59]

Imposing even more virtual dispatch seems to be bad to me. Hrm.

[abarth-chromium, 2013/12/09 21:19:34]

Jumping through a function pointer is the same as jumping through a virtual
function call.  If you're worried about folks who call these functions directly,
we can mark CoreImpl FINAL.

 
-  MojoResult Close(MojoHandle handle);
+  virtual MojoResult Wait(MojoHandle handle,
+                          MojoWaitFlags flags,
+                          MojoDeadline deadline) OVERRIDE;
 
-  MojoResult Wait(MojoHandle handle,
-                  MojoWaitFlags flags,
-                  MojoDeadline deadline);
+  virtual MojoResult WaitMany(const MojoHandle* handles,
+                              const MojoWaitFlags* flags,
+                              uint32_t num_handles,
+                              MojoDeadline deadline) OVERRIDE;
 
-  MojoResult WaitMany(const MojoHandle* handles,
-                      const MojoWaitFlags* flags,
-                      uint32_t num_handles,
-                      MojoDeadline deadline);
+  virtual MojoResult CreateMessagePipe(MojoHandle* handle_0,
+                                       MojoHandle* handle_1) OVERRIDE;
 
-  MojoResult CreateMessagePipe(MojoHandle* handle_0, MojoHandle* handle_1);
+  virtual MojoResult WriteMessage(MojoHandle handle,
+                                  const void* bytes,
+                                  uint32_t num_bytes,
+                                  const MojoHandle* handles,
+                                  uint32_t num_handles,
+                                  MojoWriteMessageFlags flags) OVERRIDE;
 
-  MojoResult WriteMessage(MojoHandle handle,
-                          const void* bytes, uint32_t num_bytes,
-                          const MojoHandle* handles, uint32_t num_handles,
-                          MojoWriteMessageFlags flags);
+  virtual MojoResult ReadMessage(MojoHandle handle,
+                                 void* bytes,
+                                 uint32_t* num_bytes,
+                                 MojoHandle* handles,
+                                 uint32_t* num_handles,
+                                 MojoReadMessageFlags flags) OVERRIDE;
 
-  MojoResult ReadMessage(MojoHandle handle,
-                         void* bytes, uint32_t* num_bytes,
-                         MojoHandle* handles, uint32_t* num_handles,
-                         MojoReadMessageFlags flags);
-
-  MojoTimeTicks GetTimeTicksNow();
+  virtual MojoTimeTicks GetTimeTicksNow() OVERRIDE;
 
  private:
   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
@@ skipping 20 matching lines @@
     HandleTableEntry();
     explicit HandleTableEntry(const scoped_refptr<Dispatcher>& dispatcher);
     ~HandleTableEntry();
 
     scoped_refptr<Dispatcher> dispatcher;
     bool busy;
   };
   typedef base::hash_map<MojoHandle, HandleTableEntry> HandleTableMap;
 
   CoreImpl();
-  ~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
   // validation of arguments.
   MojoResult WaitManyInternal(const MojoHandle* handles,
                               const MojoWaitFlags* flags,
                               uint32_t num_handles,
                               MojoDeadline deadline);
 
   // ---------------------------------------------------------------------------
 
-  static CoreImpl* singleton_;
-
-  // ---------------------------------------------------------------------------
-
   // TODO(vtl): |handle_table_lock_| should be a reader-writer lock (if only we
   // had them).
   base::Lock handle_table_lock_;  // Protects the immediately-following members.
   HandleTableMap handle_table_;
   MojoHandle next_handle_;  // Invariant: never |MOJO_HANDLE_INVALID|.
 
   // ---------------------------------------------------------------------------
 
   DISALLOW_COPY_AND_ASSIGN(CoreImpl);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_CORE_IMPL_H_