Make mojo_system static and mojo_system_impl a component, never use both

mojo/system/core.cc

Index: mojo/system/core.cc
diff --git a/mojo/system/core_impl.cc b/mojo/system/core.cc
similarity index 66%
rename from mojo/system/core_impl.cc
rename to mojo/system/core.cc
index 12c1be5756977212da38be4eccd4cfc2443bf09f..c0f3ab05b169ebe0d85425bd1fd01c2b22c9ae43 100644
--- a/mojo/system/core_impl.cc
+++ b/mojo/system/core.cc
@@ -2,12 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "mojo/system/core_impl.h"
+#include "mojo/system/core.h"
 
 #include <vector>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/time/time.h"
+#include "mojo/public/c/system/core.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/data_pipe.h"
 #include "mojo/system/data_pipe_consumer_dispatcher.h"
@@ -21,16 +23,19 @@
 #include "mojo/system/shared_buffer_dispatcher.h"
 #include "mojo/system/waiter.h"
 
+static base::LazyInstance<mojo::system::Core> g_core =

[viettrungluu, 2014/04/09 20:26:52]

Please don't do this. Core should be explicitly created and torn down. This was
a conscious decision.

[DaveMoore, 2014/04/09 22:49:08]

Done.

+    LAZY_INSTANCE_INITIALIZER;
+
 namespace mojo {
 namespace system {
 
 // Implementation notes
 //
-// Mojo primitives are implemented by the singleton |CoreImpl| object. Most
+// Mojo primitives are implemented by the singleton |Core| object. Most
 // calls are for a "primary" handle (the first argument).
-// |CoreImpl::GetDispatcher()| is used to look up a |Dispatcher| object for a
+// |Core::GetDispatcher()| is used to look up a |Dispatcher| object for a
 // given handle. That object implements most primitives for that object. The
-// wait primitives are not attached to objects and are implemented by |CoreImpl|
+// wait primitives are not attached to objects and are implemented by |Core|
 // itself.
 //
 // Some objects have multiple handles associated to them, e.g., message pipes
@@ -73,39 +78,43 @@ namespace system {
 //    - Locks at the "INF" level may not have any locks taken while they are
 //      held.
 
-CoreImpl::HandleTableEntry::HandleTableEntry()
+Core::HandleTableEntry::HandleTableEntry()
     : busy(false) {
 }
 
-CoreImpl::HandleTableEntry::HandleTableEntry(
+Core::HandleTableEntry::HandleTableEntry(
     const scoped_refptr<Dispatcher>& dispatcher)
     : dispatcher(dispatcher),
       busy(false) {
 }
 
-CoreImpl::HandleTableEntry::~HandleTableEntry() {
+Core::HandleTableEntry::~HandleTableEntry() {
   DCHECK(!busy);
 }
 
-CoreImpl::CoreImpl() {
+Core* Core::GetInstance() {
+  return &g_core.Get();
+}
+
+Core::Core() {
 }
 
-CoreImpl::~CoreImpl() {
+Core::~Core() {
   // This should usually not be reached (the singleton lives forever), except in
   // tests.
 }
 
-MojoHandle CoreImpl::AddDispatcher(
+MojoHandle Core::AddDispatcher(
     const scoped_refptr<Dispatcher>& dispatcher) {
   base::AutoLock locker(handle_table_lock_);
   return handle_table_.AddDispatcher(dispatcher);
 }
 
-MojoTimeTicks CoreImpl::GetTimeTicksNow() {
+MojoTimeTicks Core::GetTimeTicksNow() {
   return base::TimeTicks::Now().ToInternalValue();
 }
 
-MojoResult CoreImpl::Close(MojoHandle handle) {
+MojoResult Core::Close(MojoHandle handle) {
   if (handle == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
@@ -125,16 +134,16 @@ MojoResult CoreImpl::Close(MojoHandle handle) {
   return dispatcher->Close();
 }
 
-MojoResult CoreImpl::Wait(MojoHandle handle,
-                          MojoWaitFlags flags,
-                          MojoDeadline deadline) {
+MojoResult Core::Wait(MojoHandle handle,
+                      MojoWaitFlags flags,
+                      MojoDeadline deadline) {
   return WaitManyInternal(&handle, &flags, 1, deadline);
 }
 
-MojoResult CoreImpl::WaitMany(const MojoHandle* handles,
-                              const MojoWaitFlags* flags,
-                              uint32_t num_handles,
-                              MojoDeadline deadline) {
+MojoResult Core::WaitMany(const MojoHandle* handles,
+                          const MojoWaitFlags* flags,
+                          uint32_t num_handles,
+                          MojoDeadline deadline) {
   if (!VerifyUserPointer<MojoHandle>(handles, num_handles))
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (!VerifyUserPointer<MojoWaitFlags>(flags, num_handles))
@@ -146,8 +155,8 @@ MojoResult CoreImpl::WaitMany(const MojoHandle* handles,
   return WaitManyInternal(handles, flags, num_handles, deadline);
 }
 
-MojoResult CoreImpl::CreateMessagePipe(MojoHandle* message_pipe_handle0,
-                                       MojoHandle* message_pipe_handle1) {
+MojoResult Core::CreateMessagePipe(MojoHandle* message_pipe_handle0,
+                                   MojoHandle* message_pipe_handle1) {
   if (!VerifyUserPointer<MojoHandle>(message_pipe_handle0, 1))
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (!VerifyUserPointer<MojoHandle>(message_pipe_handle1, 1))
@@ -185,12 +194,12 @@ MojoResult CoreImpl::CreateMessagePipe(MojoHandle* message_pipe_handle0,
 // isn't done, in the in-process case, calls on the old handle may complete
 // after the the message has been received and a new handle created (and
 // possibly even after calls have been made on the new handle).
-MojoResult CoreImpl::WriteMessage(MojoHandle message_pipe_handle,
-                                  const void* bytes,
-                                  uint32_t num_bytes,
-                                  const MojoHandle* handles,
-                                  uint32_t num_handles,
-                                  MojoWriteMessageFlags flags) {
+MojoResult Core::WriteMessage(MojoHandle message_pipe_handle,
+                              const void* bytes,
+                              uint32_t num_bytes,
+                              const MojoHandle* handles,
+                              uint32_t num_handles,
+                              MojoWriteMessageFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(GetDispatcher(message_pipe_handle));
   if (!dispatcher.get())
     return MOJO_RESULT_INVALID_ARGUMENT;
@@ -249,12 +258,12 @@ MojoResult CoreImpl::WriteMessage(MojoHandle message_pipe_handle,
   return rv;
 }
 
-MojoResult CoreImpl::ReadMessage(MojoHandle message_pipe_handle,
-                                 void* bytes,
-                                 uint32_t* num_bytes,
-                                 MojoHandle* handles,
-                                 uint32_t* num_handles,
-                                 MojoReadMessageFlags flags) {
+MojoResult Core::ReadMessage(MojoHandle message_pipe_handle,
+                             void* bytes,
+                             uint32_t* num_bytes,
+                             MojoHandle* handles,
+                             uint32_t* num_handles,
+                             MojoReadMessageFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(GetDispatcher(message_pipe_handle));
   if (!dispatcher.get())
     return MOJO_RESULT_INVALID_ARGUMENT;
@@ -298,9 +307,9 @@ MojoResult CoreImpl::ReadMessage(MojoHandle message_pipe_handle,
   return rv;
 }
 
-MojoResult CoreImpl::CreateDataPipe(const MojoCreateDataPipeOptions* options,
-                                    MojoHandle* data_pipe_producer_handle,
-                                    MojoHandle* data_pipe_consumer_handle) {
+MojoResult Core::CreateDataPipe(const MojoCreateDataPipeOptions* options,
+                                MojoHandle* data_pipe_producer_handle,
+                                MojoHandle* data_pipe_consumer_handle) {
   if (options) {
     // The |struct_size| field must be valid to read.
     if (!VerifyUserPointer<uint32_t>(&options->struct_size, 1))
@@ -348,10 +357,10 @@ MojoResult CoreImpl::CreateDataPipe(const MojoCreateDataPipeOptions* options,
   return MOJO_RESULT_OK;
 }
 
-MojoResult CoreImpl::WriteData(MojoHandle data_pipe_producer_handle,
-                               const void* elements,
-                               uint32_t* num_bytes,
-                               MojoWriteDataFlags flags) {
+MojoResult Core::WriteData(MojoHandle data_pipe_producer_handle,
+                           const void* elements,
+                           uint32_t* num_bytes,
+                           MojoWriteDataFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_producer_handle));
   if (!dispatcher.get())
@@ -360,10 +369,10 @@ MojoResult CoreImpl::WriteData(MojoHandle data_pipe_producer_handle,
   return dispatcher->WriteData(elements, num_bytes, flags);
 }
 
-MojoResult CoreImpl::BeginWriteData(MojoHandle data_pipe_producer_handle,
-                                    void** buffer,
-                                    uint32_t* buffer_num_bytes,
-                                    MojoWriteDataFlags flags) {
+MojoResult Core::BeginWriteData(MojoHandle data_pipe_producer_handle,
+                                void** buffer,
+                                uint32_t* buffer_num_bytes,
+                                MojoWriteDataFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_producer_handle));
   if (!dispatcher.get())
@@ -372,8 +381,8 @@ MojoResult CoreImpl::BeginWriteData(MojoHandle data_pipe_producer_handle,
   return dispatcher->BeginWriteData(buffer, buffer_num_bytes, flags);
 }
 
-MojoResult CoreImpl::EndWriteData(MojoHandle data_pipe_producer_handle,
-                                  uint32_t num_bytes_written) {
+MojoResult Core::EndWriteData(MojoHandle data_pipe_producer_handle,
+                              uint32_t num_bytes_written) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_producer_handle));
   if (!dispatcher.get())
@@ -382,10 +391,10 @@ MojoResult CoreImpl::EndWriteData(MojoHandle data_pipe_producer_handle,
   return dispatcher->EndWriteData(num_bytes_written);
 }
 
-MojoResult CoreImpl::ReadData(MojoHandle data_pipe_consumer_handle,
-                              void* elements,
-                              uint32_t* num_bytes,
-                              MojoReadDataFlags flags) {
+MojoResult Core::ReadData(MojoHandle data_pipe_consumer_handle,
+                          void* elements,
+                          uint32_t* num_bytes,
+                          MojoReadDataFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_consumer_handle));
   if (!dispatcher.get())
@@ -394,10 +403,10 @@ MojoResult CoreImpl::ReadData(MojoHandle data_pipe_consumer_handle,
   return dispatcher->ReadData(elements, num_bytes, flags);
 }
 
-MojoResult CoreImpl::BeginReadData(MojoHandle data_pipe_consumer_handle,
-                                   const void** buffer,
-                                   uint32_t* buffer_num_bytes,
-                                   MojoReadDataFlags flags) {
+MojoResult Core::BeginReadData(MojoHandle data_pipe_consumer_handle,
+                               const void** buffer,
+                               uint32_t* buffer_num_bytes,
+                               MojoReadDataFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_consumer_handle));
   if (!dispatcher.get())
@@ -406,8 +415,8 @@ MojoResult CoreImpl::BeginReadData(MojoHandle data_pipe_consumer_handle,
   return dispatcher->BeginReadData(buffer, buffer_num_bytes, flags);
 }
 
-MojoResult CoreImpl::EndReadData(MojoHandle data_pipe_consumer_handle,
-                                 uint32_t num_bytes_read) {
+MojoResult Core::EndReadData(MojoHandle data_pipe_consumer_handle,
+                             uint32_t num_bytes_read) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_consumer_handle));
   if (!dispatcher.get())
@@ -416,7 +425,7 @@ MojoResult CoreImpl::EndReadData(MojoHandle data_pipe_consumer_handle,
   return dispatcher->EndReadData(num_bytes_read);
 }
 
-MojoResult CoreImpl::CreateSharedBuffer(
+MojoResult Core::CreateSharedBuffer(
     const MojoCreateSharedBufferOptions* options,
     uint64_t num_bytes,
     MojoHandle* shared_buffer_handle) {
@@ -456,7 +465,7 @@ MojoResult CoreImpl::CreateSharedBuffer(
   return MOJO_RESULT_OK;
 }
 
-MojoResult CoreImpl::DuplicateBufferHandle(
+MojoResult Core::DuplicateBufferHandle(
     MojoHandle buffer_handle,
     const MojoDuplicateBufferHandleOptions* options,
     MojoHandle* new_buffer_handle) {
@@ -485,11 +494,11 @@ MojoResult CoreImpl::DuplicateBufferHandle(
   return MOJO_RESULT_OK;
 }
 
-MojoResult CoreImpl::MapBuffer(MojoHandle buffer_handle,
-                               uint64_t offset,
-                               uint64_t num_bytes,
-                               void** buffer,
-                               MojoMapBufferFlags flags) {
+MojoResult Core::MapBuffer(MojoHandle buffer_handle,
+                           uint64_t offset,
+                           uint64_t num_bytes,
+                           void** buffer,
+                           MojoMapBufferFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(GetDispatcher(buffer_handle));
   if (!dispatcher.get())
     return MOJO_RESULT_INVALID_ARGUMENT;
@@ -515,12 +524,12 @@ MojoResult CoreImpl::MapBuffer(MojoHandle buffer_handle,
   return MOJO_RESULT_OK;
 }
 
-MojoResult CoreImpl::UnmapBuffer(void* buffer) {
+MojoResult Core::UnmapBuffer(void* buffer) {
   base::AutoLock locker(mapping_table_lock_);
   return mapping_table_.RemoveMapping(buffer);
 }
 
-scoped_refptr<Dispatcher> CoreImpl::GetDispatcher(MojoHandle handle) {
+scoped_refptr<Dispatcher> Core::GetDispatcher(MojoHandle handle) {
   if (handle == MOJO_HANDLE_INVALID)
     return NULL;
 
@@ -532,10 +541,10 @@ scoped_refptr<Dispatcher> CoreImpl::GetDispatcher(MojoHandle handle) {
 // different flags may be specified.
 // TODO(vtl): This incurs a performance cost in |RemoveWaiter()|. Analyze this
 // more carefully and address it if necessary.
-MojoResult CoreImpl::WaitManyInternal(const MojoHandle* handles,
-                                      const MojoWaitFlags* flags,
-                                      uint32_t num_handles,
-                                      MojoDeadline deadline) {
+MojoResult Core::WaitManyInternal(const MojoHandle* handles,
+                                  const MojoWaitFlags* flags,
+                                  uint32_t num_handles,
+                                  MojoDeadline deadline) {
   DCHECK_GT(num_handles, 0u);
 
   std::vector<scoped_refptr<Dispatcher> > dispatchers;
@@ -578,3 +587,147 @@ MojoResult CoreImpl::WaitManyInternal(const MojoHandle* handles,
 
 }  // namespace system
 }  // namespace mojo
+
+// Definitions of the MojoCore functions.

[viettrungluu, 2014/04/09 20:26:52]

Please put these in a separate file. This file is already too big.

(I wouldn't have minded keeping it as "CoreImpl", and just having the extern "C"
bits in core.cc.

[DaveMoore, 2014/04/09 22:49:08]

Done.

+extern "C" {
+
+MojoTimeTicks MojoGetTimeTicksNow() {
+  return g_core.Get().GetTimeTicksNow();
+}
+
+MojoResult MojoClose(MojoHandle handle) {
+  return g_core.Get().Close(handle);
+}
+
+MojoResult MojoWait(MojoHandle handle,
+                    MojoWaitFlags flags,
+                    MojoDeadline deadline) {
+  return g_core.Get().Wait(handle, flags, deadline);
+}
+
+MojoResult MojoWaitMany(const MojoHandle* handles,
+                        const MojoWaitFlags* flags,
+                        uint32_t num_handles,
+                        MojoDeadline deadline) {
+  return g_core.Get().WaitMany(handles, flags, num_handles, deadline);
+}
+
+MojoResult MojoCreateMessagePipe(MojoHandle* message_pipe_handle0,
+                                 MojoHandle* message_pipe_handle1) {
+  return g_core.Get().CreateMessagePipe(message_pipe_handle0,
+                                        message_pipe_handle1);
+}
+
+MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
+                            const void* bytes,
+                            uint32_t num_bytes,
+                            const MojoHandle* handles,
+                            uint32_t num_handles,
+                            MojoWriteMessageFlags flags) {
+  return g_core.Get().WriteMessage(message_pipe_handle,
+                                   bytes, num_bytes,
+                                   handles, num_handles,
+                                   flags);
+}
+
+MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
+                           void* bytes,
+                           uint32_t* num_bytes,
+                           MojoHandle* handles,
+                           uint32_t* num_handles,
+                           MojoReadMessageFlags flags) {
+  return g_core.Get().ReadMessage(message_pipe_handle,
+                                  bytes, num_bytes,
+                                  handles, num_handles,
+                                  flags);
+}
+
+MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options,
+                              MojoHandle* data_pipe_producer_handle,
+                              MojoHandle* data_pipe_consumer_handle) {
+  return g_core.Get().CreateDataPipe(options,
+                                     data_pipe_producer_handle,
+                                     data_pipe_consumer_handle);
+}
+
+MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle,
+                         const void* elements,
+                         uint32_t* num_elements,
+                         MojoWriteDataFlags flags) {
+  return g_core.Get().WriteData(data_pipe_producer_handle,
+                                elements, num_elements,
+                                flags);
+}
+
+MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle,
+                              void** buffer,
+                              uint32_t* buffer_num_elements,
+                              MojoWriteDataFlags flags) {
+  return g_core.Get().BeginWriteData(data_pipe_producer_handle,
+                                     buffer, buffer_num_elements,
+                                     flags);
+}
+
+MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle,
+                            uint32_t num_elements_written) {
+  return g_core.Get().EndWriteData(data_pipe_producer_handle,
+                                   num_elements_written);
+}
+
+MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle,
+                        void* elements,
+                        uint32_t* num_elements,
+                        MojoReadDataFlags flags) {
+  return g_core.Get().ReadData(data_pipe_consumer_handle,
+                               elements, num_elements,
+                               flags);
+}
+
+MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle,
+                             const void** buffer,
+                             uint32_t* buffer_num_elements,
+                             MojoReadDataFlags flags) {
+  return g_core.Get().BeginReadData(data_pipe_consumer_handle,
+                                    buffer, buffer_num_elements,
+                                    flags);
+}
+
+MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle,
+                           uint32_t num_elements_read) {
+  return g_core.Get().EndReadData(data_pipe_consumer_handle, num_elements_read);
+}
+
+MojoResult MojoCreateSharedBuffer(
+    const struct MojoCreateSharedBufferOptions* options,
+    uint64_t num_bytes,
+    MojoHandle* shared_buffer_handle) {
+  return g_core.Get().CreateSharedBuffer(options,
+                                         num_bytes,
+                                         shared_buffer_handle);
+}
+
+MojoResult MojoDuplicateBufferHandle(
+    MojoHandle buffer_handle,
+    const struct MojoDuplicateBufferHandleOptions* options,
+    MojoHandle* new_buffer_handle) {
+  return g_core.Get().DuplicateBufferHandle(buffer_handle,
+                                            options,
+                                            new_buffer_handle);
+}
+
+MojoResult MojoMapBuffer(MojoHandle buffer_handle,
+                         uint64_t offset,
+                         uint64_t num_bytes,
+                         void** buffer,
+                         MojoMapBufferFlags flags) {
+  return g_core.Get().MapBuffer(buffer_handle,
+                                offset, num_bytes,
+                                buffer,
+                                flags);
+}
+
+MojoResult MojoUnmapBuffer(void* buffer) {
+  return g_core.Get().UnmapBuffer(buffer);
+}
+
+}  // extern "C"