Revert 263717 "Make mojo_system static and mojo_system_impl a co..."

Reason for revert: broke Win x64 Builder: 
http://build.chromium.org/p/chromium.win/builders/Win%20x64%20Builder/builds/17235/

> Make mojo_system static and mojo_system_impl a component, never use both
> 
> BUG=
> R=viettrungluu@chromium.org
> 
> Review URL: https://codereview.chromium.org/231353002

TBR=davemoore@chromium.org

Review URL: https://codereview.chromium.org/237703002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@263722 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 156 insertions, 196 deletions

diff --git a/mojo/public/platform/native/system_thunks.h b/mojo/public/platform/native/system_thunks.h
deleted file mode 100644
index 9c366e5..0000000
--- a/mojo/public/platform/native/system_thunks.h
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2014 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_PUBLIC_PLATFORM_NATIVE_SYSTEM_THUNKS_H_
-#define MOJO_PUBLIC_PLATFORM_NATIVE_SYSTEM_THUNKS_H_
-
-#include <stddef.h>
-
-#include "mojo/public/c/system/core.h"
-
-// The embedder needs to bind the basic Mojo Core functions of a DSO to those of
-// the embedder when loading a DSO that is dependent on mojo_system.
-// The typical usage would look like:
-// base::ScopedNativeLibrary app_library(
-//     base::LoadNativeLibrary(app_path_, &error));
-// typedef MojoResult (*MojoSetSystemThunksFn)(MojoSystemThunks*);
-// MojoSetSystemThunksFn mojo_set_system_thunks_fn =
-//     reinterpret_cast<MojoSetSystemThunksFn>(app_library.GetFunctionPointer(
-//         "MojoSetSystemThunks"));
-// MojoSystemThunks system_thunks = MojoMakeSystemThunks();
-// size_t expected_size = mojo_set_system_thunks_fn(&system_thunks);
-// if (expected_size > sizeof(MojoSystemThunks)) {
-//   LOG(ERROR)
-//       << "Invalid DSO. Expected MojoSystemThunks size: "
-//       << expected_size;
-//   break;
-// }
-
-// Structure used to bind the basic Mojo Core functions of a DSO to those of
-// the embedder.
-// This is the ABI between the embedder and the DSO. It can only have new
-// functions added to the end. No other changes are supported.
-#pragma pack(push, 8)
-struct MojoSystemThunks {
-  size_t size;  // Should be set to sizeof(MojoSystemThunks).
-  MojoTimeTicks (*GetTimeTicksNow)();
-  MojoResult (*Close)(MojoHandle handle);
-  MojoResult (*Wait)(MojoHandle handle,
-                     MojoWaitFlags flags,
-                     MojoDeadline deadline);
-  MojoResult (*WaitMany)(const MojoHandle* handles,
-                         const MojoWaitFlags* flags,
-                         uint32_t num_handles,
-                         MojoDeadline deadline);
-  MojoResult (*CreateMessagePipe)(MojoHandle* message_pipe_handle0,
-                                  MojoHandle* message_pipe_handle1);
-  MojoResult (*WriteMessage)(MojoHandle message_pipe_handle,
-                             const void* bytes,
-                             uint32_t num_bytes,
-                             const MojoHandle* handles,
-                             uint32_t num_handles,
-                             MojoWriteMessageFlags flags);
-  MojoResult (*ReadMessage)(MojoHandle message_pipe_handle,
-                            void* bytes,
-                            uint32_t* num_bytes,
-                            MojoHandle* handles,
-                            uint32_t* num_handles,
-                            MojoReadMessageFlags flags);
-  MojoResult (*CreateDataPipe)(const MojoCreateDataPipeOptions* options,
-                               MojoHandle* data_pipe_producer_handle,
-                               MojoHandle* data_pipe_consumer_handle);
-  MojoResult (*WriteData)(MojoHandle data_pipe_producer_handle,
-                          const void* elements,
-                          uint32_t* num_elements,
-                          MojoWriteDataFlags flags);
-  MojoResult (*BeginWriteData)(MojoHandle data_pipe_producer_handle,
-                               void** buffer,
-                               uint32_t* buffer_num_elements,
-                               MojoWriteDataFlags flags);
-  MojoResult (*EndWriteData)(MojoHandle data_pipe_producer_handle,
-                             uint32_t num_elements_written);
-  MojoResult (*ReadData)(MojoHandle data_pipe_consumer_handle,
-                         void* elements,
-                         uint32_t* num_elements,
-                         MojoReadDataFlags flags);
-  MojoResult (*BeginReadData)(MojoHandle data_pipe_consumer_handle,
-                              const void** buffer,
-                              uint32_t* buffer_num_elements,
-                              MojoReadDataFlags flags);
-  MojoResult (*EndReadData)(MojoHandle data_pipe_consumer_handle,
-                            uint32_t num_elements_read);
-  MojoResult (*CreateSharedBuffer)(
-      const MojoCreateSharedBufferOptions* options,
-      uint64_t num_bytes,
-      MojoHandle* shared_buffer_handle);
-  MojoResult (*DuplicateBufferHandle)(
-      MojoHandle buffer_handle,
-      const MojoDuplicateBufferHandleOptions* options,
-      MojoHandle* new_buffer_handle);
-  MojoResult (*MapBuffer)(MojoHandle buffer_handle,
-                          uint64_t offset,
-                          uint64_t num_bytes,
-                          void** buffer,
-                          MojoMapBufferFlags flags);
-  MojoResult (*UnmapBuffer)(void* buffer);
-};
-#pragma pack(pop)
-
-// Intended to be called from the embedder. Returns a |MojoCore| initialized
-// to contain pointers to each of the embedder's MojoCore functions.
-inline MojoSystemThunks MojoMakeSystemThunks() {
-  MojoSystemThunks system_thunks = {
-    sizeof(MojoSystemThunks),
-    MojoGetTimeTicksNow,
-    MojoClose,
-    MojoWait,
-    MojoWaitMany,
-    MojoCreateMessagePipe,
-    MojoWriteMessage,
-    MojoReadMessage,
-    MojoCreateDataPipe,
-    MojoWriteData,
-    MojoBeginWriteData,
-    MojoEndWriteData,
-    MojoReadData,
-    MojoBeginReadData,
-    MojoEndReadData,
-    MojoCreateSharedBuffer,
-    MojoDuplicateBufferHandle,
-    MojoMapBuffer,
-    MojoUnmapBuffer
-  };
-  return system_thunks;
-}
-
-// Use this type for the function found by dynamically discovering it in
-// a DSO linked with mojo_system. For example:
-// MojoSetSystemThunksFn mojo_set_system_thunks_fn =
-//     reinterpret_cast<MojoSetSystemThunksFn>(app_library.GetFunctionPointer(
-//         "MojoSetSystemThunks"));
-// The expected size of |system_thunks} is returned.
-// The contents of |system_thunks| are copied.
-typedef size_t (*MojoSetSystemThunksFn)(const MojoSystemThunks* system_thunks);
-
-#endif  // MOJO_PUBLIC_PLATFORM_NATIVE_SYSTEM_THUNKS_H_
diff --git a/mojo/public/platform/native/system_thunks.cc b/mojo/public/system/core_private.cc
index bd82b00..bd9d6b8 100644
--- a/mojo/public/platform/native/system_thunks.cc
+++ b/mojo/public/system/core_private.cc
@@ -2,43 +2,44 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "mojo/public/platform/native/system_thunks.h"
+#include "mojo/public/system/core_private.h"
 
 #include <assert.h>
+#include <stddef.h>
 
-extern "C" {
+static mojo::Core* g_core = NULL;
 
-static MojoSystemThunks g_thunks = {0};
+extern "C" {
 
 MojoTimeTicks MojoGetTimeTicksNow() {
-  assert(g_thunks.GetTimeTicksNow);
-  return g_thunks.GetTimeTicksNow();
+  assert(g_core);
+  return g_core->GetTimeTicksNow();
 }
 
 MojoResult MojoClose(MojoHandle handle) {
-  assert(g_thunks.Close);
-  return g_thunks.Close(handle);
+  assert(g_core);
+  return g_core->Close(handle);
 }
 
 MojoResult MojoWait(MojoHandle handle,
                     MojoWaitFlags flags,
                     MojoDeadline deadline) {
-  assert(g_thunks.Wait);
-  return g_thunks.Wait(handle, flags, deadline);
+  assert(g_core);
+  return g_core->Wait(handle, flags, deadline);
 }
 
 MojoResult MojoWaitMany(const MojoHandle* handles,
                         const MojoWaitFlags* flags,
                         uint32_t num_handles,
                         MojoDeadline deadline) {
-  assert(g_thunks.WaitMany);
-  return g_thunks.WaitMany(handles, flags, num_handles, deadline);
+  assert(g_core);
+  return g_core->WaitMany(handles, flags, num_handles, deadline);
 }
 
 MojoResult MojoCreateMessagePipe(MojoHandle* message_pipe_handle0,
                                  MojoHandle* message_pipe_handle1) {
-  assert(g_thunks.CreateMessagePipe);
-  return g_thunks.CreateMessagePipe(message_pipe_handle0, message_pipe_handle1);
+  assert(g_core);
+  return g_core->CreateMessagePipe(message_pipe_handle0, message_pipe_handle1);
 }
 
 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
@@ -47,9 +48,9 @@ MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
                             const MojoHandle* handles,
                             uint32_t num_handles,
                             MojoWriteMessageFlags flags) {
-  assert(g_thunks.WriteMessage);
-  return g_thunks.WriteMessage(message_pipe_handle, bytes, num_bytes, handles,
-                               num_handles, flags);
+  assert(g_core);
+  return g_core->WriteMessage(message_pipe_handle, bytes, num_bytes, handles,
+                              num_handles, flags);
 }
 
 MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
@@ -58,82 +59,82 @@ MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
                            MojoHandle* handles,
                            uint32_t* num_handles,
                            MojoReadMessageFlags flags) {
-  assert(g_thunks.ReadMessage);
-  return g_thunks.ReadMessage(message_pipe_handle, bytes, num_bytes, handles,
-                              num_handles, flags);
+  assert(g_core);
+  return g_core->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) {
-  assert(g_thunks.CreateDataPipe);
-  return g_thunks.CreateDataPipe(options, data_pipe_producer_handle,
-                                 data_pipe_consumer_handle);
+  assert(g_core);
+  return g_core->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) {
-  assert(g_thunks.WriteData);
-  return g_thunks.WriteData(data_pipe_producer_handle, elements, num_elements,
-                            flags);
+  assert(g_core);
+  return g_core->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) {
-  assert(g_thunks.BeginWriteData);
-  return g_thunks.BeginWriteData(data_pipe_producer_handle, buffer,
-                                 buffer_num_elements, flags);
+  assert(g_core);
+  return g_core->BeginWriteData(data_pipe_producer_handle, buffer,
+                                buffer_num_elements, flags);
 }
 
 MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle,
                             uint32_t num_elements_written) {
-  assert(g_thunks.EndWriteData);
-  return g_thunks.EndWriteData(data_pipe_producer_handle, num_elements_written);
+  assert(g_core);
+  return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written);
 }
 
 MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle,
                         void* elements,
                         uint32_t* num_elements,
                         MojoReadDataFlags flags) {
-  assert(g_thunks.ReadData);
-  return g_thunks.ReadData(data_pipe_consumer_handle, elements, num_elements,
-                           flags);
+  assert(g_core);
+  return g_core->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) {
-  assert(g_thunks.BeginReadData);
-  return g_thunks.BeginReadData(data_pipe_consumer_handle, buffer,
-                                buffer_num_elements, flags);
+  assert(g_core);
+  return g_core->BeginReadData(data_pipe_consumer_handle, buffer,
+                               buffer_num_elements, flags);
 }
 
 MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle,
                            uint32_t num_elements_read) {
-  assert(g_thunks.EndReadData);
-  return g_thunks.EndReadData(data_pipe_consumer_handle, num_elements_read);
+  assert(g_core);
+  return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read);
 }
 
 MojoResult MojoCreateSharedBuffer(
     const struct MojoCreateSharedBufferOptions* options,
     uint64_t num_bytes,
     MojoHandle* shared_buffer_handle) {
-  assert(g_thunks.CreateSharedBuffer);
-  return g_thunks.CreateSharedBuffer(options, num_bytes, shared_buffer_handle);
+  assert(g_core);
+  return g_core->CreateSharedBuffer(options, num_bytes, shared_buffer_handle);
 }
 
 MojoResult MojoDuplicateBufferHandle(
     MojoHandle buffer_handle,
     const struct MojoDuplicateBufferHandleOptions* options,
     MojoHandle* new_buffer_handle) {
-  assert(g_thunks.DuplicateBufferHandle);
-  return g_thunks.DuplicateBufferHandle(buffer_handle, options,
-                                        new_buffer_handle);
+  assert(g_core);
+  return g_core->DuplicateBufferHandle(buffer_handle, options,
+                                       new_buffer_handle);
 }
 
 MojoResult MojoMapBuffer(MojoHandle buffer_handle,
@@ -141,28 +142,36 @@ MojoResult MojoMapBuffer(MojoHandle buffer_handle,
                          uint64_t num_bytes,
                          void** buffer,
                          MojoMapBufferFlags flags) {
-  assert(g_thunks.MapBuffer);
-  return g_thunks.MapBuffer(buffer_handle, offset, num_bytes, buffer, flags);
+  assert(g_core);
+  return g_core->MapBuffer(buffer_handle, offset, num_bytes, buffer, flags);
 }
 
 MojoResult MojoUnmapBuffer(void* buffer) {
-  assert(g_thunks.UnmapBuffer);
-  return g_thunks.UnmapBuffer(buffer);
+  assert(g_core);
+  return g_core->UnmapBuffer(buffer);
 }
 
-// Call this function by looking
-// Always export this api.
-#if defined(WIN32)
-#define THUNK_EXPORT __declspec(dllexport)
-#else
-#define THUNK_EXPORT __attribute__((visibility("default")))
-#endif
+}  // extern "C"
 
-extern "C" THUNK_EXPORT size_t MojoSetSystemThunks(
-    const MojoSystemThunks* system_thunks) {
-  if (system_thunks->size >= sizeof(g_thunks))
-    g_thunks = *system_thunks;
-  return sizeof(g_thunks);
+namespace mojo {
+
+Core::~Core() {
 }
 
-}  // extern "C"
+// static
+void Core::Init(Core* core) {
+  assert(!g_core);
+  g_core = core;
+}
+
+// static
+Core* Core::Get() {
+  return g_core;
+}
+
+// static
+void Core::Reset() {
+  g_core = NULL;
+}
+
+}  // namespace mojo
diff --git a/mojo/public/system/core_private.h b/mojo/public/system/core_private.h
new file mode 100644
index 0000000..057bfca
--- /dev/null
+++ b/mojo/public/system/core_private.h
@@ -0,0 +1,87 @@
+// 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_PUBLIC_SYSTEM_CORE_PRIVATE_H_
+#define MOJO_PUBLIC_SYSTEM_CORE_PRIVATE_H_
+
+#include "mojo/public/c/system/core.h"
+
+namespace mojo {
+
+// Implementors of the core APIs can use this interface to install their
+// implementation into the mojo_system dynamic library. Mojo clients should not
+// call these functions directly.
+class MOJO_SYSTEM_EXPORT Core {
+ public:
+  virtual ~Core();
+
+  static void Init(Core* core);
+  static Core* Get();
+  static void Reset();
+
+  virtual MojoTimeTicks GetTimeTicksNow() = 0;
+  virtual MojoResult Close(MojoHandle handle) = 0;
+  virtual MojoResult Wait(MojoHandle handle,
+                          MojoWaitFlags flags,
+                          MojoDeadline deadline) = 0;
+  virtual MojoResult WaitMany(const MojoHandle* handles,
+                              const MojoWaitFlags* flags,
+                              uint32_t num_handles,
+                              MojoDeadline deadline) = 0;
+  virtual MojoResult CreateMessagePipe(MojoHandle* message_pipe_handle0,
+                                       MojoHandle* message_pipe_handle1) = 0;
+  virtual MojoResult WriteMessage(MojoHandle message_pipe_handle,
+                                  const void* bytes,
+                                  uint32_t num_bytes,
+                                  const MojoHandle* handles,
+                                  uint32_t num_handles,
+                                  MojoWriteMessageFlags flags) = 0;
+  virtual MojoResult ReadMessage(MojoHandle message_pipe_handle,
+                                 void* bytes,
+                                 uint32_t* num_bytes,
+                                 MojoHandle* handles,
+                                 uint32_t* num_handles,
+                                 MojoReadMessageFlags flags) = 0;
+  virtual MojoResult CreateDataPipe(const MojoCreateDataPipeOptions* options,
+                                    MojoHandle* data_pipe_producer_handle,
+                                    MojoHandle* data_pipe_consumer_handle) = 0;
+  virtual MojoResult WriteData(MojoHandle data_pipe_producer_handle,
+                               const void* elements,
+                               uint32_t* num_elements,
+                               MojoWriteDataFlags flags) = 0;
+  virtual MojoResult BeginWriteData(MojoHandle data_pipe_producer_handle,
+                                    void** buffer,
+                                    uint32_t* buffer_num_elements,
+                                    MojoWriteDataFlags flags) = 0;
+  virtual MojoResult EndWriteData(MojoHandle data_pipe_producer_handle,
+                                  uint32_t num_elements_written) = 0;
+  virtual MojoResult ReadData(MojoHandle data_pipe_consumer_handle,
+                              void* elements,
+                              uint32_t* num_elements,
+                              MojoReadDataFlags flags) = 0;
+  virtual MojoResult BeginReadData(MojoHandle data_pipe_consumer_handle,
+                                   const void** buffer,
+                                   uint32_t* buffer_num_elements,
+                                   MojoReadDataFlags flags) = 0;
+  virtual MojoResult EndReadData(MojoHandle data_pipe_consumer_handle,
+                                 uint32_t num_elements_read) = 0;
+  virtual MojoResult CreateSharedBuffer(
+      const MojoCreateSharedBufferOptions* options,
+      uint64_t num_bytes,
+      MojoHandle* shared_buffer_handle) = 0;
+  virtual MojoResult DuplicateBufferHandle(
+      MojoHandle buffer_handle,
+      const MojoDuplicateBufferHandleOptions* options,
+      MojoHandle* new_buffer_handle) = 0;
+  virtual MojoResult MapBuffer(MojoHandle buffer_handle,
+                               uint64_t offset,
+                               uint64_t num_bytes,
+                               void** buffer,
+                               MojoMapBufferFlags flags) = 0;
+  virtual MojoResult UnmapBuffer(void* buffer) = 0;
+};
+
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_SYSTEM_CORE_PRIVATE_H_