Rename mojo::TokenSerializer to mojo::Broker.

mojo/runner/host/child_process.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/runner/host/child_process.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 90 matching lines @@
 // Should be created and initialized on the main thread.
 // TODO(use_chrome_edk)
 // class AppContext : public edk::ProcessDelegate {
 class AppContext : public embedder::ProcessDelegate {
  public:
   AppContext()
       : io_thread_("io_thread"), controller_thread_("controller_thread") {}
   ~AppContext() override {}
 
   void Init() {
-#if defined(OS_WIN)
     embedder::PreInitializeChildProcess();
-#endif
-
     // Initialize Mojo before starting any threads.
     embedder::Init();
 
     // Create and start our I/O thread.
     base::Thread::Options io_thread_options(base::MessageLoop::TYPE_IO, 0);
     CHECK(io_thread_.StartWithOptions(io_thread_options));
     io_runner_ = io_thread_.task_runner().get();
     CHECK(io_runner_.get());
 
     // TODO(vtl): This should be SLAVE, not NONE.
@@ skipping 183 matching lines @@
       platform_channel.Pass(), base::Bind(&DidCreateChannel), io_task_runner));
 
 #if defined(OS_WIN)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk")) {
     // When using the new Mojo EDK, each message pipe is backed by a platform
     // handle. The one platform handle that comes on the command line is used
     // to bind to the ChildController interface. However we also want a
     // platform handle to setup the communication channel by which we exchange
     // handles to/from tokens, which is needed for sandboxed Windows
     // processes.
-    char token_serializer_handle[10];
+    char broker_handle[10];
     MojoHandleSignalsState state;
     MojoResult rv =
         MojoWait(host_message_pipe.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
                  MOJO_DEADLINE_INDEFINITE, &state);
     CHECK_EQ(MOJO_RESULT_OK, rv);
-    uint32_t num_bytes = arraysize(token_serializer_handle);
+    uint32_t num_bytes = arraysize(broker_handle);
     rv = MojoReadMessage(host_message_pipe.get().value(),
-                         token_serializer_handle, &num_bytes, nullptr, 0,
+                         broker_handle, &num_bytes, nullptr, 0,
                          MOJO_READ_MESSAGE_FLAG_NONE);
     CHECK_EQ(MOJO_RESULT_OK, rv);
 
-    edk::ScopedPlatformHandle token_serializer_channel =
+    edk::ScopedPlatformHandle broker_channel =
         edk::PlatformChannelPair::PassClientHandleFromParentProcessFromString(
-            std::string(token_serializer_handle, num_bytes));
-    CHECK(token_serializer_channel.is_valid());
-    embedder::SetParentPipeHandle(token_serializer_channel.release().handle);
+            std::string(broker_handle, num_bytes));
+    CHECK(broker_channel.is_valid());
+    embedder::SetParentPipeHandle(
+        mojo::embedder::ScopedPlatformHandle(mojo::embedder::PlatformHandle(
+            broker_channel.release().
+#if defined(OS_WIN)

[yzshen1, 2015/11/25 16:47:09]

Does it make sense to have helper methods (in either class) to convert between
edk::ScopedPlatformHandle and mojo::embedder::ScopedPlatformHandle? That way we
don't have to do this in multiple places.

Besides, is it possible to change |handle| and |fd| to the same name, say
|value|? I don't see the benefit of having different names on different
platforms. :/

[jam, 2015/11/25 16:56:09]

I thought of that; but the goal should be to delete the old edk soon and so
that's why i was ok with this extra code.
I agree! Although I think it should be done outside this change.

+                                    handle
+#else
+                                    fd
+#endif
+            )));
   }
+#else
+  // TODO(jam): hook up on POSIX
 #endif
 
   return host_message_pipe.Pass();
 }
 
 }  // namespace
 
 int ChildProcessMain() {
   DVLOG(2) << "ChildProcessMain()";
   const base::CommandLine& command_line =
@@ skipping 34 matching lines @@
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 
   return 0;
 }
 
 }  // namespace runner
 }  // namespace mojo