[mojo] Ports EDK

mojo/edk/embedder/embedder.cc

 // 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.
 
 #include "mojo/edk/embedder/embedder.h"
 
-#include <stddef.h>
 #include <stdint.h>
 
-#include <utility>
-
-#include "base/atomicops.h"
 #include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "crypto/random.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/process_delegate.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
-#include "mojo/edk/system/broker_state.h"
-#include "mojo/edk/system/child_broker.h"
-#include "mojo/edk/system/child_broker_host.h"
-#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.h"
-#include "mojo/edk/system/message_pipe_dispatcher.h"
-#include "mojo/edk/system/platform_handle_dispatcher.h"
 
 namespace mojo {
 namespace edk {
 
+class Core;
+class PlatformSupport;
+
 namespace internal {
 
-// Declared in embedder_internal.h.
-Broker* g_broker = nullptr;
-PlatformSupport* g_platform_support = nullptr;
-Core* g_core = nullptr;
+Core* g_core;
+base::TaskRunner* g_io_thread_task_runner;
+PlatformSupport* g_platform_support;
+ProcessDelegate* g_process_delegate;
 
-ProcessDelegate* g_process_delegate;
-base::TaskRunner* g_io_thread_task_runner = nullptr;
+// This is used to help negotiate message pipe connections over arbitrary
+// platform channels. The embedder needs to know which end of the pipe it's on
+// so it can do the right thing.
+//
+// TODO: Remove this when people stop using mojo::embedder::CreateChannel()
+// and thus mojo::edk::CreateMessagePipe(ScopedPlatformHandle).
+bool g_is_parent_process = true;
 
-Core* GetCore() {
-  return g_core;
-}
+Core* GetCore() { return g_core; }
 
 }  // namespace internal
 
 void SetMaxMessageSize(size_t bytes) {
-  GetMutableConfiguration()->max_message_num_bytes = bytes;
 }
 
 void PreInitializeParentProcess() {
-  BrokerState::GetInstance();
 }
 
 void PreInitializeChildProcess() {
-  ChildBroker::GetInstance();
+  internal::g_is_parent_process = false;
 }
 
 ScopedPlatformHandle ChildProcessLaunched(base::ProcessHandle child_process) {
-  PlatformChannelPair token_channel;
-  new ChildBrokerHost(child_process, token_channel.PassServerHandle());
-  return token_channel.PassClientHandle();
+  PlatformChannelPair channel;
+  ChildProcessLaunched(child_process, channel.PassServerHandle());
+  return channel.PassClientHandle();
 }
 
 void ChildProcessLaunched(base::ProcessHandle child_process,
                           ScopedPlatformHandle server_pipe) {
-  new ChildBrokerHost(child_process, std::move(server_pipe));
+  CHECK(internal::g_core);
+  internal::g_core->AddChild(child_process, std::move(server_pipe));
 }
 
 void SetParentPipeHandle(ScopedPlatformHandle pipe) {
-  ChildBroker::GetInstance()->SetChildBrokerHostHandle(std::move(pipe));
+  CHECK(internal::g_core);
+  internal::g_is_parent_process = false;
+  internal::g_core->InitChild(std::move(pipe));
 }
 
 void Init() {
-  const base::CommandLine& command_line =
-      *base::CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch("use-new-edk") && !internal::g_broker)
-    BrokerState::GetInstance();
-
-  DCHECK(!internal::g_platform_support);
+  internal::g_core = new Core();
   internal::g_platform_support = new SimplePlatformSupport();
-
-  DCHECK(!internal::g_core);
-  internal::g_core = new Core(internal::g_platform_support);
 }
 
 MojoResult AsyncWait(MojoHandle handle,
                      MojoHandleSignals signals,
                      const base::Callback<void(MojoResult)>& callback) {
+  CHECK(internal::g_core);
   return internal::g_core->AsyncWait(handle, signals, callback);
 }
 
 MojoResult CreatePlatformHandleWrapper(
     ScopedPlatformHandle platform_handle,
     MojoHandle* platform_handle_wrapper_handle) {
-  DCHECK(platform_handle_wrapper_handle);
-
-  scoped_refptr<Dispatcher> dispatcher =
-      PlatformHandleDispatcher::Create(std::move(platform_handle));
-
-  DCHECK(internal::g_core);
-  MojoHandle h = internal::g_core->AddDispatcher(dispatcher);
-  if (h == MOJO_HANDLE_INVALID) {
-    LOG(ERROR) << "Handle table full";
-    dispatcher->Close();
-    return MOJO_RESULT_RESOURCE_EXHAUSTED;
-  }
-
-  *platform_handle_wrapper_handle = h;
-  return MOJO_RESULT_OK;
+  return internal::g_core->CreatePlatformHandleWrapper(
+      std::move(platform_handle), platform_handle_wrapper_handle);
 }
 
 MojoResult PassWrappedPlatformHandle(MojoHandle platform_handle_wrapper_handle,
                                      ScopedPlatformHandle* platform_handle) {
-  DCHECK(platform_handle);
-
-  DCHECK(internal::g_core);
-  scoped_refptr<Dispatcher> dispatcher(
-      internal::g_core->GetDispatcher(platform_handle_wrapper_handle));
-  if (!dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  if (dispatcher->GetType() != Dispatcher::Type::PLATFORM_HANDLE)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  *platform_handle = static_cast<PlatformHandleDispatcher*>(dispatcher.get())
-                         ->PassPlatformHandle();
-  return MOJO_RESULT_OK;
+  return internal::g_core->PassWrappedPlatformHandle(
+      platform_handle_wrapper_handle, platform_handle);
 }
 
 void InitIPCSupport(ProcessDelegate* process_delegate,
                     scoped_refptr<base::TaskRunner> io_thread_task_runner) {
-  // |Init()| must have already been called.
-  DCHECK(internal::g_core);
+  CHECK(internal::g_core);
+  CHECK(!internal::g_io_thread_task_runner);
+  internal::g_io_thread_task_runner = io_thread_task_runner.get();
+  internal::g_io_thread_task_runner->AddRef();
+
+  internal::g_core->SetIOTaskRunner(io_thread_task_runner);
   internal::g_process_delegate = process_delegate;
-  internal::g_io_thread_task_runner = io_thread_task_runner.get();
 }
 
 void ShutdownIPCSupportOnIOThread() {
 }
 
 void ShutdownIPCSupport() {
-  // TODO(jam): remove ProcessDelegate from new EDK once the old EDK is gone.
-  internal::g_process_delegate->OnShutdownComplete();
+  CHECK(internal::g_process_delegate);
+  CHECK(internal::g_core);
+  internal::g_core->RequestShutdown(
+      base::Bind(&ProcessDelegate::OnShutdownComplete,
+                 base::Unretained(internal::g_process_delegate)));
 }
 
 ScopedMessagePipeHandle CreateMessagePipe(
     ScopedPlatformHandle platform_handle) {
-  MojoCreateMessagePipeOptions options = {
-      static_cast<uint32_t>(sizeof(MojoCreateMessagePipeOptions)),
-      MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_TRANSFERABLE};
-  scoped_refptr<MessagePipeDispatcher> dispatcher =
-      MessagePipeDispatcher::Create(options);
+  NOTREACHED();
+  return ScopedMessagePipeHandle();
+}
 
-  ScopedMessagePipeHandle rv(
-      MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher)));
-  CHECK(rv.is_valid());
-  dispatcher->Init(std::move(platform_handle), nullptr, 0, nullptr, 0, nullptr,
-                   nullptr);
-  // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
-  // once that's fixed.
-  return rv;
+void CreateMessagePipe(
+    ScopedPlatformHandle platform_handle,
+    const base::Callback<void(ScopedMessagePipeHandle)>& callback) {
+  DCHECK(internal::g_core);
+  if (internal::g_is_parent_process) {
+    internal::g_core->CreateParentMessagePipe(std::move(platform_handle),
+                                              callback);
+  } else {
+    internal::g_core->CreateChildMessagePipe(std::move(platform_handle),
+                                             callback);
+  }
+}
+
+void CreateParentMessagePipe(
+    const std::string& token,
+    const base::Callback<void(ScopedMessagePipeHandle)>& callback) {
+  DCHECK(internal::g_core);
+  internal::g_core->CreateParentMessagePipe(token, callback);
+}
+
+void CreateChildMessagePipe(
+    const std::string& token,
+    const base::Callback<void(ScopedMessagePipeHandle)>& callback) {
+  DCHECK(internal::g_core);
+  internal::g_core->CreateChildMessagePipe(token, callback);
+}
+
+std::string GenerateRandomToken() {
+  char random_bytes[16];
+  crypto::RandBytes(random_bytes, 16);
+  return base::HexEncode(random_bytes, 16);
 }
 
 }  // namespace edk
 }  // namespace mojo