Rename mojo::TokenSerializer to mojo::Broker.

mojo/edk/system/simple_broker.cc

 // 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/system/simple_token_serializer_win.h"
-
-#include <windows.h>
+#include "mojo/edk/system/simple_broker.h"
 
 #include "base/process/process.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
 namespace mojo {
 namespace edk {
 
-SimpleTokenSerializer::SimpleTokenSerializer() {
+SimpleBroker::SimpleBroker() {
 }
 
-SimpleTokenSerializer::~SimpleTokenSerializer() {
+SimpleBroker::~SimpleBroker() {
 }
 
-void SimpleTokenSerializer::CreatePlatformChannelPair(
+#if defined(OS_WIN)
+void SimpleBroker::CreatePlatformChannelPair(
     ScopedPlatformHandle* server, ScopedPlatformHandle* client) {
   PlatformChannelPair channel_pair;
   *server = channel_pair.PassServerHandle();
   *client = channel_pair.PassClientHandle();
 }
 
-void SimpleTokenSerializer::HandleToToken(
-    const PlatformHandle* platform_handles,
-    size_t count,
-    uint64_t* tokens) {
+void SimpleBroker::HandleToToken(const PlatformHandle* platform_handles,
+                                 size_t count,
+                                 uint64_t* tokens) {
   // Since we're not sure which process might ultimately deserialize the message
   // we can't duplicate the handle now. Instead, write the process ID and handle
   // now and let the receiver duplicate it.
   uint32_t current_process_id = base::GetCurrentProcId();
   for (size_t i = 0; i < count; ++i) {
     tokens[i] = current_process_id;
     tokens[i] = tokens[i] << 32;
     // Windows HANDLES are always 32 bit per
     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203(v=vs.85).aspx
 #if defined(_WIN64)
     tokens[i] |= static_cast<int32_t>(
         reinterpret_cast<int64_t>(platform_handles[i].handle));
 #else
     tokens[i] |= reinterpret_cast<int32_t>(platform_handles[i].handle);
 #endif
   }
 }
 
-void SimpleTokenSerializer::TokenToHandle(const uint64_t* tokens,
-                                          size_t count,
-                                          PlatformHandle* handles) {
+void SimpleBroker::TokenToHandle(const uint64_t* tokens,
+                                 size_t count,
+                                 PlatformHandle* handles) {
   for (size_t i = 0; i < count; ++i) {
     DWORD pid = tokens[i] >> 32;
 #if defined(_WIN64)
     // Sign-extend to preserve INVALID_HANDLE_VALUE.
     HANDLE source_handle = reinterpret_cast<HANDLE>(
         static_cast<int64_t>(static_cast<int32_t>(tokens[i] & 0xFFFFFFFF)));
 #else
     HANDLE source_handle = reinterpret_cast<HANDLE>(tokens[i] & 0xFFFFFFFF);
 #endif
     base::Process sender =
         base::Process::OpenWithAccess(pid, PROCESS_DUP_HANDLE);
     handles[i] = PlatformHandle();
     if (!sender.IsValid()) {
       // Sender died.
     } else {
       BOOL dup_result = DuplicateHandle(
           sender.Handle(), source_handle,
           base::GetCurrentProcessHandle(), &handles[i].handle, 0,
           FALSE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
       DCHECK(dup_result);
     }
   }
 }
+#endif
 
 }  // namespace edk
 }  // namespace mojo