src/mojo/edk/system/data_pipe_consumer_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/edk/system/data_pipe_consumer_dispatcher.h"
   6
   7 #include "base/logging.h"
   8 #include "mojo/edk/system/data_pipe.h"
   9 #include "mojo/edk/system/memory.h"
  10
  11 namespace mojo {
  12 namespace system {
  13
  14 DataPipeConsumerDispatcher::DataPipeConsumerDispatcher() {
  15 }
  16
  17 void DataPipeConsumerDispatcher::Init(scoped_refptr<DataPipe> data_pipe) {
  18   DCHECK(data_pipe.get());
  19   data_pipe_ = data_pipe;
  20 }
  21
  22 Dispatcher::Type DataPipeConsumerDispatcher::GetType() const {
  23   return kTypeDataPipeConsumer;
  24 }
  25
  26 DataPipeConsumerDispatcher::~DataPipeConsumerDispatcher() {
  27   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
  28   DCHECK(!data_pipe_.get());
  29 }
  30
  31 void DataPipeConsumerDispatcher::CancelAllWaitersNoLock() {
  32   lock().AssertAcquired();
  33   data_pipe_->ConsumerCancelAllWaiters();
  34 }
  35
  36 void DataPipeConsumerDispatcher::CloseImplNoLock() {
  37   lock().AssertAcquired();
  38   data_pipe_->ConsumerClose();
  39   data_pipe_ = nullptr;
  40 }
  41
  42 scoped_refptr<Dispatcher>
  43 DataPipeConsumerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
  44   lock().AssertAcquired();
  45
  46   scoped_refptr<DataPipeConsumerDispatcher> rv =
  47       new DataPipeConsumerDispatcher();
  48   rv->Init(data_pipe_);
  49   data_pipe_ = nullptr;
  50   return scoped_refptr<Dispatcher>(rv.get());
  51 }
  52
  53 MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock(
  54     UserPointer<void> elements,
  55     UserPointer<uint32_t> num_bytes,
  56     MojoReadDataFlags flags) {
  57   lock().AssertAcquired();
  58
  59   if ((flags & MOJO_READ_DATA_FLAG_DISCARD)) {
  60     // These flags are mutally exclusive.
  61     if ((flags & MOJO_READ_DATA_FLAG_QUERY) ||
  62         (flags & MOJO_READ_DATA_FLAG_PEEK))
  63       return MOJO_RESULT_INVALID_ARGUMENT;
  64     DVLOG_IF(2, !elements.IsNull())
  65         << "Discard mode: ignoring non-null |elements|";
  66     return data_pipe_->ConsumerDiscardData(
  67         num_bytes, (flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE));
  68   }
  69
  70   if ((flags & MOJO_READ_DATA_FLAG_QUERY)) {
  71     if ((flags & MOJO_READ_DATA_FLAG_PEEK))
  72       return MOJO_RESULT_INVALID_ARGUMENT;
  73     DCHECK(!(flags & MOJO_READ_DATA_FLAG_DISCARD));  // Handled above.
  74     DVLOG_IF(2, !elements.IsNull())
  75         << "Query mode: ignoring non-null |elements|";
  76     return data_pipe_->ConsumerQueryData(num_bytes);
  77   }
  78
  79   return data_pipe_->ConsumerReadData(
  80       elements,
  81       num_bytes,
  82       !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE),
  83       !!(flags & MOJO_READ_DATA_FLAG_PEEK));
  84 }
  85
  86 MojoResult DataPipeConsumerDispatcher::BeginReadDataImplNoLock(
  87     UserPointer<const void*> buffer,
  88     UserPointer<uint32_t> buffer_num_bytes,
  89     MojoReadDataFlags flags) {
  90   lock().AssertAcquired();
  91
  92   // These flags may not be used in two-phase mode.
  93   if ((flags & MOJO_READ_DATA_FLAG_DISCARD) ||
  94       (flags & MOJO_READ_DATA_FLAG_QUERY) ||
  95       (flags & MOJO_READ_DATA_FLAG_PEEK))
  96     return MOJO_RESULT_INVALID_ARGUMENT;
  97
  98   return data_pipe_->ConsumerBeginReadData(
  99       buffer, buffer_num_bytes, (flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 100 }
 101
 102 MojoResult DataPipeConsumerDispatcher::EndReadDataImplNoLock(
 103     uint32_t num_bytes_read) {
 104   lock().AssertAcquired();
 105
 106   return data_pipe_->ConsumerEndReadData(num_bytes_read);
 107 }
 108
 109 HandleSignalsState DataPipeConsumerDispatcher::GetHandleSignalsStateImplNoLock()
 110     const {
 111   lock().AssertAcquired();
 112   return data_pipe_->ConsumerGetHandleSignalsState();
 113 }
 114
 115 MojoResult DataPipeConsumerDispatcher::AddWaiterImplNoLock(
 116     Waiter* waiter,
 117     MojoHandleSignals signals,
 118     uint32_t context,
 119     HandleSignalsState* signals_state) {
 120   lock().AssertAcquired();
 121   return data_pipe_->ConsumerAddWaiter(waiter, signals, context, signals_state);
 122 }
 123
 124 void DataPipeConsumerDispatcher::RemoveWaiterImplNoLock(
 125     Waiter* waiter,
 126     HandleSignalsState* signals_state) {
 127   lock().AssertAcquired();
 128   data_pipe_->ConsumerRemoveWaiter(waiter, signals_state);
 129 }
 130
 131 bool DataPipeConsumerDispatcher::IsBusyNoLock() const {
 132   lock().AssertAcquired();
 133   return data_pipe_->ConsumerIsBusy();
 134 }
 135
 136 }  // namespace system
 137 }  // namespace mojo