EDK: Move DispatcherTransport to handle_transport.*.

mojo/edk/system/dispatcher.cc

 // 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.
 
 #include "mojo/edk/system/dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
+#include "mojo/edk/system/handle_transport.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
 
 using mojo::platform::PlatformSharedBufferMapping;
 using mojo::platform::ScopedPlatformHandle;
 using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
 namespace test {
 
 // TODO(vtl): Maybe this should be defined in a test-only file instead.
 DispatcherTransport DispatcherTryStartTransport(Dispatcher* dispatcher) {
   return Dispatcher::HandleTableAccess::TryStartTransport(dispatcher);
 }
 
 }  // namespace test
 
-// Dispatcher ------------------------------------------------------------------
-
 // TODO(vtl): The thread-safety analyzer isn't smart enough to deal with the
 // fact that we give up if |TryLock()| fails.
 // static
 DispatcherTransport Dispatcher::HandleTableAccess::TryStartTransport(
     Dispatcher* dispatcher) MOJO_NO_THREAD_SAFETY_ANALYSIS {
   DCHECK(dispatcher);
 
   if (!dispatcher->mutex_.TryLock())
     return DispatcherTransport();
 
@@ skipping 249 matching lines @@
   MutexLocker locker(&mutex_);
   if (is_closed_) {
     if (handle_signals_state)
       *handle_signals_state = HandleSignalsState();
     return;
   }
 
   RemoveAwakableImplNoLock(awakable, handle_signals_state);
 }
 
-Dispatcher::Dispatcher() : is_closed_(false) {
-}
+Dispatcher::Dispatcher() : is_closed_(false) {}
 
 Dispatcher::~Dispatcher() {
   // Make sure that |Close()| was called.
   DCHECK(is_closed_);
 }
 
 void Dispatcher::CancelAllAwakablesNoLock() {
   mutex_.AssertHeld();
   DCHECK(is_closed_);
   // By default, waiting isn't supported. Only dispatchers that can be waited on
@@ skipping 251 matching lines @@
   // See the comment above |EndSerializeAndCloseImplNoLock()|. In brief: Locking
   // isn't actually needed, but we need to satisfy assertions (which we don't
   // want to remove or weaken).
   MutexLocker locker(&mutex_);
 #endif
 
   return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
                                         platform_handles);
 }
 
-// DispatcherTransport ---------------------------------------------------------
-
-void DispatcherTransport::End() {
-  DCHECK(dispatcher_);
-  dispatcher_->mutex_.Unlock();
-  dispatcher_ = nullptr;
-}
-
 }  // namespace system
 }  // namespace mojo