src/mojo/system/data_pipe_producer_dispatcher.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/system/data_pipe_producer_dispatcher.h"
   6
   7 #include "base/logging.h"
   8 #include "mojo/system/data_pipe.h"
   9 #include "mojo/system/memory.h"
  10
  11 namespace mojo {
  12 namespace system {
  13
  14 DataPipeProducerDispatcher::DataPipeProducerDispatcher() {
  15 }
  16
  17 void DataPipeProducerDispatcher::Init(scoped_refptr<DataPipe> data_pipe) {
  18   DCHECK(data_pipe.get());
  19   data_pipe_ = data_pipe;
  20 }
  21
  22 Dispatcher::Type DataPipeProducerDispatcher::GetType() const {
  23   return kTypeDataPipeProducer;
  24 }
  25
  26 DataPipeProducerDispatcher::~DataPipeProducerDispatcher() {
  27   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
  28   DCHECK(!data_pipe_.get());
  29 }
  30
  31 void DataPipeProducerDispatcher::CancelAllWaitersNoLock() {
  32   lock().AssertAcquired();
  33   data_pipe_->ProducerCancelAllWaiters();
  34 }
  35
  36 void DataPipeProducerDispatcher::CloseImplNoLock() {
  37   lock().AssertAcquired();
  38   data_pipe_->ProducerClose();
  39   data_pipe_ = nullptr;
  40 }
  41
  42 scoped_refptr<Dispatcher>
  43 DataPipeProducerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
  44   lock().AssertAcquired();
  45
  46   scoped_refptr<DataPipeProducerDispatcher> rv =
  47       new DataPipeProducerDispatcher();
  48   rv->Init(data_pipe_);
  49   data_pipe_ = nullptr;
  50   return scoped_refptr<Dispatcher>(rv.get());
  51 }
  52
  53 MojoResult DataPipeProducerDispatcher::WriteDataImplNoLock(
  54     UserPointer<const void> elements,
  55     UserPointer<uint32_t> num_bytes,
  56     MojoWriteDataFlags flags) {
  57   lock().AssertAcquired();
  58   return data_pipe_->ProducerWriteData(
  59       elements, num_bytes, (flags & MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
  60 }
  61
  62 MojoResult DataPipeProducerDispatcher::BeginWriteDataImplNoLock(
  63     UserPointer<void*> buffer,
  64     UserPointer<uint32_t> buffer_num_bytes,
  65     MojoWriteDataFlags flags) {
  66   lock().AssertAcquired();
  67
  68   return data_pipe_->ProducerBeginWriteData(
  69       buffer, buffer_num_bytes, (flags & MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
  70 }
  71
  72 MojoResult DataPipeProducerDispatcher::EndWriteDataImplNoLock(
  73     uint32_t num_bytes_written) {
  74   lock().AssertAcquired();
  75
  76   return data_pipe_->ProducerEndWriteData(num_bytes_written);
  77 }
  78
  79 HandleSignalsState DataPipeProducerDispatcher::GetHandleSignalsStateImplNoLock()
  80     const {
  81   lock().AssertAcquired();
  82   return data_pipe_->ProducerGetHandleSignalsState();
  83 }
  84
  85 MojoResult DataPipeProducerDispatcher::AddWaiterImplNoLock(
  86     Waiter* waiter,
  87     MojoHandleSignals signals,
  88     uint32_t context,
  89     HandleSignalsState* signals_state) {
  90   lock().AssertAcquired();
  91   return data_pipe_->ProducerAddWaiter(waiter, signals, context, signals_state);
  92 }
  93
  94 void DataPipeProducerDispatcher::RemoveWaiterImplNoLock(
  95     Waiter* waiter,
  96     HandleSignalsState* signals_state) {
  97   lock().AssertAcquired();
  98   data_pipe_->ProducerRemoveWaiter(waiter, signals_state);
  99 }
 100
 101 bool DataPipeProducerDispatcher::IsBusyNoLock() const {
 102   lock().AssertAcquired();
 103   return data_pipe_->ProducerIsBusy();
 104 }
 105
 106 }  // namespace system
 107 }  // namespace mojo