Update mojo sdk to rev 3d23dae011859a2aae49f1d1adde705c8e85d819

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"
@@ skipping 30 matching lines @@
     embedder::SlaveProcessDelegate* slave_process_delegate,
     embedder::ScopedPlatformHandle platform_handle) {
   DCHECK(delegate_thread_task_runner);
   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();
+  AssertNotOnPrivateThread();
   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;
@@ skipping 213 matching lines @@
 
   raw_channel_->Shutdown();
   raw_channel_.reset();
 
   DCHECK(slave_process_delegate_);
   delegate_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&embedder::SlaveProcessDelegate::OnMasterDisconnect,
                             base::Unretained(slave_process_delegate_)));
 }
 
-void SlaveConnectionManager::AssertOnDelegateThread() const {
-  DCHECK(base::MessageLoop::current());
-  DCHECK_EQ(base::MessageLoop::current()->task_runner(),
-            delegate_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