EDK: Split embedder.* into embedder.* and multiprocess_embedder.*.

mojo/edk/embedder/multiprocess_embedder.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2015 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 "mojo/edk/embedder/multiprocess_embedder.h"
 
 #include <utility>
 
 #include "base/atomicops.h"
 #include "base/logging.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
-#include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/embedder/process_delegate.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_manager.h"
-#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/ipc_support.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
-#include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/util/ref_ptr.h"
 
 using mojo::platform::PlatformHandleWatcher;
 using mojo::platform::ScopedPlatformHandle;
 using mojo::platform::TaskRunner;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace embedder {
 
 namespace internal {
 
 // Declared in embedder_internal.h.
-PlatformSupport* g_platform_support = nullptr;
-system::Core* g_core = nullptr;
 system::IPCSupport* g_ipc_support = nullptr;
 
 }  // namespace internal
 
 namespace {
 
 // TODO(vtl): For now, we need this to be thread-safe (since theoretically we
 // currently support multiple channel creation threads -- possibly one per
 // channel). Eventually, we won't need it to be thread-safe (we'll require a
 // single I/O thread), and eventually we won't need it at all. Remember to
 // remove the base/atomicops.h include.
 system::ChannelId MakeChannelId() {
   // Note that |AtomicWord| is signed.
   static base::subtle::AtomicWord counter = 0;
 
   base::subtle::AtomicWord new_counter_value =
       base::subtle::NoBarrier_AtomicIncrement(&counter, 1);
   // Don't allow the counter to wrap. Note that any (strictly) positive value is
   // a valid |ChannelId| (and |NoBarrier_AtomicIncrement()| returns the value
   // post-increment).
   CHECK_GT(new_counter_value, 0);
   // Use "negative" values for these IDs, so that we'll also be able to use
   // "positive" "process identifiers" (see connection_manager.h) as IDs (and
   // they won't conflict).
   return static_cast<system::ChannelId>(-new_counter_value);
 }
 
 }  // namespace
 
-Configuration* GetConfiguration() {
-  return system::GetMutableConfiguration();
-}
-
-void Init(std::unique_ptr<PlatformSupport> platform_support) {
-  DCHECK(platform_support);
-
-  DCHECK(!internal::g_platform_support);
-  internal::g_platform_support = platform_support.release();
-
-  DCHECK(!internal::g_core);
-  internal::g_core = new system::Core(internal::g_platform_support);
-}
-
-MojoResult AsyncWait(MojoHandle handle,
-                     MojoHandleSignals signals,
-                     const std::function<void(MojoResult)>& callback) {
-  return internal::g_core->AsyncWait(handle, signals, callback);
-}
-
-MojoResult CreatePlatformHandleWrapper(
-    ScopedPlatformHandle platform_handle,
-    MojoHandle* platform_handle_wrapper_handle) {
-  DCHECK(platform_handle_wrapper_handle);
-
-  auto dispatcher =
-      system::PlatformHandleDispatcher::Create(platform_handle.Pass());
-
-  DCHECK(internal::g_core);
-  MojoHandle h = internal::g_core->AddDispatcher(dispatcher.get());
-  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;
-}
-
-MojoResult PassWrappedPlatformHandle(MojoHandle platform_handle_wrapper_handle,
-                                     ScopedPlatformHandle* platform_handle) {
-  DCHECK(platform_handle);
-
-  DCHECK(internal::g_core);
-  auto dispatcher =
-      internal::g_core->GetDispatcher(platform_handle_wrapper_handle);
-  if (!dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  if (dispatcher->GetType() != system::Dispatcher::Type::PLATFORM_HANDLE)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  *platform_handle =
-      static_cast<system::PlatformHandleDispatcher*>(dispatcher.get())
-          ->PassPlatformHandle();
-  return MOJO_RESULT_OK;
-}
-
 void InitIPCSupport(ProcessType process_type,
                     RefPtr<TaskRunner>&& delegate_thread_task_runner,
                     ProcessDelegate* process_delegate,
                     RefPtr<TaskRunner>&& io_task_runner,
                     PlatformHandleWatcher* io_watcher,
                     ScopedPlatformHandle platform_handle) {
   // |Init()| must have already been called.
   DCHECK(internal::g_core);
   // And not |InitIPCSupport()| (without |ShutdownIPCSupport()|).
   DCHECK(!internal::g_ipc_support);
@@ skipping 166 matching lines @@
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
   channel_manager->WillShutdownChannel(channel_info->channel_id);
 }
 
 }  // namespace embedder
 }  // namespace mojo