[mojo] Ports EDK

mojo/edk/system/core.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_EDK_SYSTEM_CORE_H_
 #define MOJO_EDK_SYSTEM_CORE_H_
 
-#include <stdint.h>
+#include <vector>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
+#include "base/task_runner.h"
+#include "mojo/edk/embedder/scoped_platform_handle.h"
+#include "mojo/edk/system/dispatcher.h"
+#include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/handle_table.h"
 #include "mojo/edk/system/mapping_table.h"
+#include "mojo/edk/system/node_controller.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/types.h"
-#include "mojo/public/cpp/system/macros.h"
+#include "mojo/public/cpp/system/message_pipe.h"
 
 namespace mojo {
-
 namespace edk {
 
-class Dispatcher;
-class PlatformSupport;
-struct HandleSignalsState;
-
 // |Core| is an object that implements the Mojo system calls. All public methods
 // are thread-safe.
 class MOJO_SYSTEM_IMPL_EXPORT Core {
  public:
-  // ---------------------------------------------------------------------------
-
-  // These methods are only to be used by via the embedder API (and internally):
-
-  // |*platform_support| must outlive this object.
-  explicit Core(PlatformSupport* platform_support);
+  explicit Core();
   virtual ~Core();
 
-  // Adds |dispatcher| to the handle table, returning the handle for it. Returns
-  // |MOJO_HANDLE_INVALID| on failure, namely if the handle table is full.
-  MojoHandle AddDispatcher(const scoped_refptr<Dispatcher>& dispatcher);
+  // Called exactly once, shortly after construction, and before any other
+  // methods are called on this object.
+  void SetIOTaskRunner(scoped_refptr<base::TaskRunner> io_task_runner);
 
-  // Looks up the dispatcher for the given handle. Returns null if the handle is
-  // invalid.
+  // Retrieves the NodeController for the current process.
+  NodeController* GetNodeController();
+
   scoped_refptr<Dispatcher> GetDispatcher(MojoHandle handle);
 
+  // Called in the parent process any time a new child is launched.
+  void AddChild(base::ProcessHandle process_handle,
+                ScopedPlatformHandle platform_handle);
+
+  // Called in a child process exactly once during early initialization.
+  void InitChild(ScopedPlatformHandle platform_handle);
+
+  // These each create message pipe endpoints connected to an endpoint in a
+  // remote embedder. |platform_handle| is used as a channel to negotiate the
+  // connection. This is only here to facilitate legacy embedder code. See
+  // mojo::edk::CreateMessagePipe in mojo/edk/embedder/embedder.h.
+  void CreateParentMessagePipe(
+      ScopedPlatformHandle platform_handle,
+      const base::Callback<void(ScopedMessagePipeHandle)>& callback);
+  void CreateChildMessagePipe(
+      ScopedPlatformHandle platform_handle,
+      const base::Callback<void(ScopedMessagePipeHandle)>& callback);
+
+  // Creates a message pipe endpoint associated with |token|, which a child
+  // holding the token can later locate and connect to.
+  void CreateParentMessagePipe(
+      const std::string& token,
+      const base::Callback<void(ScopedMessagePipeHandle)>& callback);
+
+  // Creates a message pipe endpoint associated with |token|, which will be
+  // passed to the parent in order to find an associated remote port and connect
+  // to it.
+  void CreateChildMessagePipe(
+      const std::string& token,
+      const base::Callback<void(ScopedMessagePipeHandle)>& callback);
+
+  MojoHandle AddDispatcher(scoped_refptr<Dispatcher> dispatcher);
+
+  // Adds new dispatchers for non-message-pipe handles received in a message.
+  // |dispatchers| and |handles| should be the same size.
+  bool AddDispatchersFromTransit(
+      const std::vector<Dispatcher::DispatcherInTransit>& dispatchers,
+      MojoHandle* handles);
+
+  MojoResult CreatePlatformHandleWrapper(ScopedPlatformHandle platform_handle,
+                                         MojoHandle* wrapper_handle);
+
+  MojoResult PassWrappedPlatformHandle(MojoHandle wrapper_handle,
+                                       ScopedPlatformHandle* platform_handle);
+
+  // Requests that the EDK tear itself down. |callback| will be called once
+  // the shutdown process is complete. Note that |callback| is always called
+  // asynchronously on the calling thread if said thread is running a message
+  // loop, and the calling thread must continue running a MessageLoop at least
+  // until the callback is called. If there is no running loop, the |callback|
+  // may be called from any thread. Beware!
+  void RequestShutdown(const base::Closure& callback);
+
   // Watches on the given handle for the given signals, calling |callback| when
   // a signal is satisfied or when all signals become unsatisfiable. |callback|
   // must satisfy stringent requirements -- see |Awakable::Awake()| in
   // awakable.h. In particular, it must not call any Mojo system functions.
   MojoResult AsyncWait(MojoHandle handle,
                        MojoHandleSignals signals,
                        const base::Callback<void(MojoResult)>& callback);
 
-  PlatformSupport* platform_support() const {
-    return platform_support_;
-  }
-
   // ---------------------------------------------------------------------------
 
   // The following methods are essentially implementations of the Mojo Core
   // functions of the Mojo API, with the C interface translated to C++ by
   // "mojo/edk/embedder/entrypoints.cc". The best way to understand the contract
   // of these methods is to look at the header files defining the corresponding
   // API functions, referenced below.
 
   // These methods correspond to the API functions defined in
   // "mojo/public/c/system/functions.h":
@@ skipping 80 matching lines @@
       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);
 
+  void GetActiveHandlesForTest(std::vector<MojoHandle>* handles);
+
  private:
-  friend bool internal::ShutdownCheckNoLeaks(Core*);
-
-  // Internal implementation of |Wait()| and |WaitMany()|; doesn't do basic
-  // validation of arguments. |*result_index| is only set if the result (whether
-  // success or failure) applies to a specific handle, so its value should be
-  // preinitialized to |static_cast<uint32_t>(-1)|.
   MojoResult WaitManyInternal(const MojoHandle* handles,
                               const MojoHandleSignals* signals,
                               uint32_t num_handles,
                               MojoDeadline deadline,
-                              uint32_t* result_index,
+                              uint32_t *result_index,
                               HandleSignalsState* signals_states);
 
-  PlatformSupport* const platform_support_;
+  // Used to pass ownership of our NodeController over to the IO thread in the
+  // event that we're torn down before said thread.
+  static void PassNodeControllerToIOThread(
+      scoped_ptr<NodeController> node_controller);
 
-  // TODO(vtl): |handle_table_lock_| should be a reader-writer lock (if only we
-  // had them).
-  base::Lock handle_table_lock_;  // Protects |handle_table_|.
-  HandleTable handle_table_;
+  // This is lazily initialized on first access. Always use GetNodeController()
+  // to access it.
+  scoped_ptr<NodeController> node_controller_;
+
+  base::Lock handles_lock_;
+  HandleTable handles_;
 
   base::Lock mapping_table_lock_;  // Protects |mapping_table_|.
   MappingTable mapping_table_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(Core);
+  DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CORE_H_