Revert of Update mojo sdk to rev 8af2ccff2eee4bfca1043015abee30482a030b30

third_party/mojo/src/mojo/edk/system/slave_connection_manager.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/slave_connection_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/system/message_in_transit.h"
 
 namespace mojo {
 namespace system {
 
 // SlaveConnectionManager ------------------------------------------------------
 
 SlaveConnectionManager::SlaveConnectionManager()
-    : slave_process_delegate_(),
+    : creation_thread_task_runner_(base::MessageLoop::current()->task_runner()),
+      slave_process_delegate_(),
       private_thread_("SlaveConnectionManagerPrivateThread"),
       awaiting_ack_type_(NOT_AWAITING_ACK),
       ack_result_(),
       ack_peer_process_identifier_(),
       ack_platform_handle_(),
       event_(false, false) {  // Auto-reset, not initially signalled.
+  DCHECK(creation_thread_task_runner_);
+  AssertOnCreationThread();  // Just make sure this assertion works correctly.
 }
 
 SlaveConnectionManager::~SlaveConnectionManager() {
-  DCHECK(!delegate_thread_task_runner_);
+  AssertOnCreationThread();
   DCHECK(!slave_process_delegate_);
   DCHECK(!private_thread_.message_loop());
   DCHECK_EQ(awaiting_ack_type_, NOT_AWAITING_ACK);
   DCHECK(!ack_result_);
   DCHECK(!ack_peer_process_identifier_);
   DCHECK(!ack_platform_handle_);
 }
 
 void SlaveConnectionManager::Init(
-    scoped_refptr<base::TaskRunner> delegate_thread_task_runner,
     embedder::SlaveProcessDelegate* slave_process_delegate,
     embedder::ScopedPlatformHandle platform_handle) {
-  DCHECK(delegate_thread_task_runner);
+  AssertOnCreationThread();
   DCHECK(slave_process_delegate);
   DCHECK(platform_handle.is_valid());
-  DCHECK(!delegate_thread_task_runner_);
   DCHECK(!slave_process_delegate_);
   DCHECK(!private_thread_.message_loop());
 
-  delegate_thread_task_runner_ = delegate_thread_task_runner;
-  AssertOnDelegateThread();
   slave_process_delegate_ = slave_process_delegate;
   CHECK(private_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   private_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&SlaveConnectionManager::InitOnPrivateThread,
                  base::Unretained(this), base::Passed(&platform_handle)));
   event_.Wait();
 }
 
 void SlaveConnectionManager::Shutdown() {
-  AssertOnDelegateThread();
+  AssertOnCreationThread();
   DCHECK(slave_process_delegate_);
   DCHECK(private_thread_.message_loop());
 
   // The |Stop()| will actually finish all posted tasks.
   private_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&SlaveConnectionManager::ShutdownOnPrivateThread,
                             base::Unretained(this)));
   private_thread_.Stop();
   slave_process_delegate_ = nullptr;
-  delegate_thread_task_runner_ = nullptr;
 }
 
 bool SlaveConnectionManager::AllowConnect(
     const ConnectionIdentifier& connection_id) {
   AssertNotOnPrivateThread();
 
   base::AutoLock locker(lock_);
   bool result = false;
   private_thread_.message_loop()->PostTask(
       FROM_HERE,
@@ skipping 198 matching lines @@
   AssertOnPrivateThread();
 
   // Ignore write errors, since we may still have some messages to read.
   if (error == RawChannel::Delegate::ERROR_WRITE)
     return;
 
   raw_channel_->Shutdown();
   raw_channel_.reset();
 
   DCHECK(slave_process_delegate_);
-  delegate_thread_task_runner_->PostTask(
+  creation_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&embedder::SlaveProcessDelegate::OnMasterDisconnect,
                             base::Unretained(slave_process_delegate_)));
 }
 
-void SlaveConnectionManager::AssertOnDelegateThread() const {
+void SlaveConnectionManager::AssertOnCreationThread() const {
   DCHECK(base::MessageLoop::current());
   DCHECK_EQ(base::MessageLoop::current()->task_runner(),
-            delegate_thread_task_runner_);
+            creation_thread_task_runner_);
 }
 
 void SlaveConnectionManager::AssertNotOnPrivateThread() const {
   // This should only be called after |Init()| and before |Shutdown()|. (If not,
   // the subsequent |DCHECK_NE()| is invalid, since the current thread may not
   // have a message loop.)
   DCHECK(private_thread_.message_loop());
   DCHECK_NE(base::MessageLoop::current(), private_thread_.message_loop());
 }
 
 void SlaveConnectionManager::AssertOnPrivateThread() const {
   // This should only be called after |Init()| and before |Shutdown()|.
   DCHECK(private_thread_.message_loop());
   DCHECK_EQ(base::MessageLoop::current(), private_thread_.message_loop());
 }
 
 }  // namespace system
 }  // namespace mojo