Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

mojo/edk/system/message_pipe_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/message_pipe_dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/memory.h"
@@ skipping 42 matching lines @@
 
   // Checks for fields beyond |flags|:
 
   // (Nothing here yet.)
 
   return MOJO_RESULT_OK;
 }
 
 void MessagePipeDispatcher::Init(scoped_refptr<MessagePipe> message_pipe,
                                  unsigned port) {
-  DCHECK(message_pipe.get());
+  DCHECK(message_pipe);
   DCHECK(port == 0 || port == 1);
 
   message_pipe_ = message_pipe;
   port_ = port;
 }
 
 Dispatcher::Type MessagePipeDispatcher::GetType() const {
   return kTypeMessagePipe;
 }
 
@@ skipping 11 matching lines @@
 
 // static
 scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size) {
   unsigned port = kInvalidPort;
   scoped_refptr<MessagePipe> message_pipe;
   if (!MessagePipe::Deserialize(channel, source, size, &message_pipe, &port))
     return nullptr;
-  DCHECK(message_pipe.get());
+  DCHECK(message_pipe);
   DCHECK(port == 0 || port == 1);
 
   scoped_refptr<MessagePipeDispatcher> dispatcher(
       new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions));
   dispatcher->Init(message_pipe, port);
   return dispatcher;
 }
 
 MessagePipeDispatcher::~MessagePipeDispatcher() {
   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
-  DCHECK(!message_pipe_.get());
+  DCHECK(!message_pipe_);
 }
 
 MessagePipe* MessagePipeDispatcher::GetMessagePipeNoLock() const {
   lock().AssertAcquired();
   return message_pipe_.get();
 }
 
 unsigned MessagePipeDispatcher::GetPortNoLock() const {
   lock().AssertAcquired();
   return port_;
 }
 
-void MessagePipeDispatcher::CancelAllWaitersNoLock() {
+void MessagePipeDispatcher::CancelAllAwakablesNoLock() {
   lock().AssertAcquired();
-  message_pipe_->CancelAllWaiters(port_);
+  message_pipe_->CancelAllAwakables(port_);
 }
 
 void MessagePipeDispatcher::CloseImplNoLock() {
   lock().AssertAcquired();
   message_pipe_->Close(port_);
   message_pipe_ = nullptr;
   port_ = kInvalidPort;
 }
 
 scoped_refptr<Dispatcher>
@@ skipping 39 matching lines @@
   return message_pipe_->ReadMessage(port_, bytes, num_bytes, dispatchers,
                                     num_dispatchers, flags);
 }
 
 HandleSignalsState MessagePipeDispatcher::GetHandleSignalsStateImplNoLock()
     const {
   lock().AssertAcquired();
   return message_pipe_->GetHandleSignalsState(port_);
 }
 
-MojoResult MessagePipeDispatcher::AddWaiterImplNoLock(
-    Waiter* waiter,
+MojoResult MessagePipeDispatcher::AddAwakableImplNoLock(
+    Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  return message_pipe_->AddWaiter(port_, waiter, signals, context,
-                                  signals_state);
+  return message_pipe_->AddAwakable(port_, awakable, signals, context,
+                                    signals_state);
 }
 
-void MessagePipeDispatcher::RemoveWaiterImplNoLock(
-    Waiter* waiter,
+void MessagePipeDispatcher::RemoveAwakableImplNoLock(
+    Awakable* awakable,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  message_pipe_->RemoveWaiter(port_, waiter, signals_state);
+  message_pipe_->RemoveAwakable(port_, awakable, signals_state);
 }
 
 void MessagePipeDispatcher::StartSerializeImplNoLock(
     Channel* channel,
     size_t* max_size,
     size_t* max_platform_handles) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   return message_pipe_->StartSerialize(port_, channel, max_size,
                                        max_platform_handles);
 }
@@ skipping 15 matching lines @@
 // MessagePipeDispatcherTransport ----------------------------------------------
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport)
     : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(), Dispatcher::kTypeMessagePipe);
 }
 
 }  // namespace system
 }  // namespace mojo