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 DataPipeProducerDispatcher::~DataPipeProducerDispatcher() {
  23   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
  24   DCHECK(!data_pipe_.get());
  25 }
  26
  27 void DataPipeProducerDispatcher::CancelAllWaitersNoLock() {
  28   lock().AssertAcquired();
  29   data_pipe_->ProducerCancelAllWaiters();
  30 }
  31
  32 MojoResult DataPipeProducerDispatcher::CloseImplNoLock() {
  33   lock().AssertAcquired();
  34   data_pipe_->ProducerClose();
  35   data_pipe_ = NULL;
  36   return MOJO_RESULT_OK;
  37 }
  38
  39 MojoResult DataPipeProducerDispatcher::WriteDataImplNoLock(
  40     const void* elements,
  41     uint32_t* num_bytes,
  42     MojoWriteDataFlags flags) {
  43   lock().AssertAcquired();
  44
  45   if (!VerifyUserPointer<uint32_t>(num_bytes, 1))
  46     return MOJO_RESULT_INVALID_ARGUMENT;
  47   if (!VerifyUserPointer<void>(elements, *num_bytes))
  48     return MOJO_RESULT_INVALID_ARGUMENT;
  49
  50   return data_pipe_->ProducerWriteData(
  51       elements, num_bytes, (flags & MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
  52 }
  53
  54 MojoResult DataPipeProducerDispatcher::BeginWriteDataImplNoLock(
  55     void** buffer,
  56     uint32_t* buffer_num_bytes,
  57     MojoWriteDataFlags flags) {
  58   lock().AssertAcquired();
  59
  60   if (!VerifyUserPointer<void*>(buffer, 1))
  61     return MOJO_RESULT_INVALID_ARGUMENT;
  62   if (!VerifyUserPointer<uint32_t>(buffer_num_bytes, 1))
  63     return MOJO_RESULT_INVALID_ARGUMENT;
  64
  65   return data_pipe_->ProducerBeginWriteData(
  66       buffer, buffer_num_bytes, (flags & MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
  67 }
  68
  69 MojoResult DataPipeProducerDispatcher::EndWriteDataImplNoLock(
  70     uint32_t num_bytes_written) {
  71   lock().AssertAcquired();
  72
  73   return data_pipe_->ProducerEndWriteData(num_bytes_written);
  74 }
  75
  76 MojoResult DataPipeProducerDispatcher::AddWaiterImplNoLock(
  77     Waiter* waiter,
  78     MojoWaitFlags flags,
  79     MojoResult wake_result) {
  80   lock().AssertAcquired();
  81   return data_pipe_->ProducerAddWaiter(waiter, flags, wake_result);
  82 }
  83
  84 void DataPipeProducerDispatcher::RemoveWaiterImplNoLock(Waiter* waiter) {
  85   lock().AssertAcquired();
  86   data_pipe_->ProducerRemoveWaiter(waiter);
  87 }
  88
  89 scoped_refptr<Dispatcher>
  90 DataPipeProducerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
  91   lock().AssertAcquired();
  92
  93   scoped_refptr<DataPipeProducerDispatcher> rv =
  94       new DataPipeProducerDispatcher();
  95   rv->Init(data_pipe_);
  96   data_pipe_ = NULL;
  97   return scoped_refptr<Dispatcher>(rv.get());
  98 }
  99
 100 }  // namespace system
 101 }  // namespace mojo