Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

mojo/edk/system/data_pipe.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_DATA_PIPE_H_
 #define MOJO_EDK_SYSTEM_DATA_PIPE_H_
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/types.h"
 
 namespace mojo {
 namespace system {
 
-class Waiter;
-class WaiterList;
+class Awakable;
+class AwakableList;
 
 // |DataPipe| is a base class for secondary objects implementing data pipes,
 // similar to |MessagePipe| (see the explanatory comment in core.cc). It is
 // typically owned by the dispatcher(s) corresponding to the local endpoints.
 // Its subclasses implement the three cases: local producer and consumer, local
 // producer and remote consumer, and remote producer and local consumer. This
 // class is thread-safe.
 class MOJO_SYSTEM_IMPL_EXPORT DataPipe
     : public base::RefCountedThreadSafe<DataPipe> {
  public:
   // The default options for |MojoCreateDataPipe()|. (Real uses should obtain
   // this via |ValidateCreateOptions()| with a null |in_options|; this is
   // exposed directly for testing convenience.)
   static MojoCreateDataPipeOptions GetDefaultCreateOptions();
 
   // Validates and/or sets default options for |MojoCreateDataPipeOptions|. If
   // non-null, |in_options| must point to a struct of at least
   // |in_options->struct_size| bytes. |out_options| must point to a (current)
   // |MojoCreateDataPipeOptions| and will be entirely overwritten on success (it
   // may be partly overwritten on failure).
   static MojoResult ValidateCreateOptions(
       UserPointer<const MojoCreateDataPipeOptions> in_options,
       MojoCreateDataPipeOptions* out_options);
 
   // These are called by the producer dispatcher to implement its methods of
   // corresponding names.
-  void ProducerCancelAllWaiters();
+  void ProducerCancelAllAwakables();
   void ProducerClose();
   MojoResult ProducerWriteData(UserPointer<const void> elements,
                                UserPointer<uint32_t> num_bytes,
                                bool all_or_none);
   MojoResult ProducerBeginWriteData(UserPointer<void*> buffer,
                                     UserPointer<uint32_t> buffer_num_bytes,
                                     bool all_or_none);
   MojoResult ProducerEndWriteData(uint32_t num_bytes_written);
   HandleSignalsState ProducerGetHandleSignalsState();
-  MojoResult ProducerAddWaiter(Waiter* waiter,
-                               MojoHandleSignals signals,
-                               uint32_t context,
-                               HandleSignalsState* signals_state);
-  void ProducerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
+  MojoResult ProducerAddAwakable(Awakable* awakable,
+                                 MojoHandleSignals signals,
+                                 uint32_t context,
+                                 HandleSignalsState* signals_state);
+  void ProducerRemoveAwakable(Awakable* awakable,
+                              HandleSignalsState* signals_state);
   bool ProducerIsBusy() const;
 
   // These are called by the consumer dispatcher to implement its methods of
   // corresponding names.
-  void ConsumerCancelAllWaiters();
+  void ConsumerCancelAllAwakables();
   void ConsumerClose();
   // This does not validate its arguments, except to check that |*num_bytes| is
   // a multiple of |element_num_bytes_|.
   MojoResult ConsumerReadData(UserPointer<void> elements,
                               UserPointer<uint32_t> num_bytes,
                               bool all_or_none,
                               bool peek);
   MojoResult ConsumerDiscardData(UserPointer<uint32_t> num_bytes,
                                  bool all_or_none);
   MojoResult ConsumerQueryData(UserPointer<uint32_t> num_bytes);
   MojoResult ConsumerBeginReadData(UserPointer<const void*> buffer,
                                    UserPointer<uint32_t> buffer_num_bytes,
                                    bool all_or_none);
   MojoResult ConsumerEndReadData(uint32_t num_bytes_read);
   HandleSignalsState ConsumerGetHandleSignalsState();
-  MojoResult ConsumerAddWaiter(Waiter* waiter,
-                               MojoHandleSignals signals,
-                               uint32_t context,
-                               HandleSignalsState* signals_state);
-  void ConsumerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state);
+  MojoResult ConsumerAddAwakable(Awakable* awakable,
+                                 MojoHandleSignals signals,
+                                 uint32_t context,
+                                 HandleSignalsState* signals_state);
+  void ConsumerRemoveAwakable(Awakable* awakable,
+                              HandleSignalsState* signals_state);
   bool ConsumerIsBusy() const;
 
  protected:
   DataPipe(bool has_local_producer,
            bool has_local_consumer,
            const MojoCreateDataPipeOptions& validated_options);
 
   friend class base::RefCountedThreadSafe<DataPipe>;
   virtual ~DataPipe();
 
@@ skipping 71 matching lines @@
   bool producer_in_two_phase_write_no_lock() const {
     lock_.AssertAcquired();
     return producer_two_phase_max_num_bytes_written_ > 0;
   }
   bool consumer_in_two_phase_read_no_lock() const {
     lock_.AssertAcquired();
     return consumer_two_phase_max_num_bytes_read_ > 0;
   }
 
  private:
-  void AwakeProducerWaitersForStateChangeNoLock(
+  void AwakeProducerAwakablesForStateChangeNoLock(
       const HandleSignalsState& new_producer_state);
-  void AwakeConsumerWaitersForStateChangeNoLock(
+  void AwakeConsumerAwakablesForStateChangeNoLock(
       const HandleSignalsState& new_consumer_state);
 
   bool has_local_producer_no_lock() const {
     lock_.AssertAcquired();
-    return !!producer_waiter_list_;
+    return !!producer_awakable_list_;
   }
   bool has_local_consumer_no_lock() const {
     lock_.AssertAcquired();
-    return !!consumer_waiter_list_;
+    return !!consumer_awakable_list_;
   }
 
   const bool may_discard_;
   const size_t element_num_bytes_;
   const size_t capacity_num_bytes_;
 
   mutable base::Lock lock_;  // Protects the following members.
   // *Known* state of producer or consumer.
   bool producer_open_;
   bool consumer_open_;
   // Non-null only if the producer or consumer, respectively, is local.
-  scoped_ptr<WaiterList> producer_waiter_list_;
-  scoped_ptr<WaiterList> consumer_waiter_list_;
+  scoped_ptr<AwakableList> producer_awakable_list_;
+  scoped_ptr<AwakableList> consumer_awakable_list_;
   // These are nonzero if and only if a two-phase write/read is in progress.
   uint32_t producer_two_phase_max_num_bytes_written_;
   uint32_t consumer_two_phase_max_num_bytes_read_;
 
   DISALLOW_COPY_AND_ASSIGN(DataPipe);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DATA_PIPE_H_