1 // Copyright 2014 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 #ifndef MOJO_PUBLIC_CPP_SYSTEM_DATA_PIPE_H_
6 #define MOJO_PUBLIC_CPP_SYSTEM_DATA_PIPE_H_
7
8 #include <assert.h>
9
10 #include "mojo/public/c/system/data_pipe.h"
11 #include "mojo/public/cpp/system/handle.h"
12 #include "mojo/public/cpp/system/macros.h"
13
14 namespace mojo {
15
16 // DataPipeProducerHandle and DataPipeConsumerHandle ---------------------------
17
18 class DataPipeProducerHandle : public Handle {
19 public:
DataPipeProducerHandle()20 DataPipeProducerHandle() {}
DataPipeProducerHandle(MojoHandle value)21 explicit DataPipeProducerHandle(MojoHandle value) : Handle(value) {}
22
23 // Copying and assignment allowed.
24 };
25
26 MOJO_COMPILE_ASSERT(sizeof(DataPipeProducerHandle) == sizeof(Handle),
27 bad_size_for_cpp_DataPipeProducerHandle);
28
29 typedef ScopedHandleBase<DataPipeProducerHandle> ScopedDataPipeProducerHandle;
30 MOJO_COMPILE_ASSERT(sizeof(ScopedDataPipeProducerHandle) ==
31 sizeof(DataPipeProducerHandle),
32 bad_size_for_cpp_ScopedDataPipeProducerHandle);
33
34 class DataPipeConsumerHandle : public Handle {
35 public:
DataPipeConsumerHandle()36 DataPipeConsumerHandle() {}
DataPipeConsumerHandle(MojoHandle value)37 explicit DataPipeConsumerHandle(MojoHandle value) : Handle(value) {}
38
39 // Copying and assignment allowed.
40 };
41
42 MOJO_COMPILE_ASSERT(sizeof(DataPipeConsumerHandle) == sizeof(Handle),
43 bad_size_for_cpp_DataPipeConsumerHandle);
44
45 typedef ScopedHandleBase<DataPipeConsumerHandle> ScopedDataPipeConsumerHandle;
46 MOJO_COMPILE_ASSERT(sizeof(ScopedDataPipeConsumerHandle) ==
47 sizeof(DataPipeConsumerHandle),
48 bad_size_for_cpp_ScopedDataPipeConsumerHandle);
49
CreateDataPipe(const MojoCreateDataPipeOptions * options,ScopedDataPipeProducerHandle * data_pipe_producer,ScopedDataPipeConsumerHandle * data_pipe_consumer)50 inline MojoResult CreateDataPipe(
51 const MojoCreateDataPipeOptions* options,
52 ScopedDataPipeProducerHandle* data_pipe_producer,
53 ScopedDataPipeConsumerHandle* data_pipe_consumer) {
54 assert(data_pipe_producer);
55 assert(data_pipe_consumer);
56 DataPipeProducerHandle producer_handle;
57 DataPipeConsumerHandle consumer_handle;
58 MojoResult rv = MojoCreateDataPipe(options, producer_handle.mutable_value(),
59 consumer_handle.mutable_value());
60 // Reset even on failure (reduces the chances that a "stale"/incorrect handle
61 // will be used).
62 data_pipe_producer->reset(producer_handle);
63 data_pipe_consumer->reset(consumer_handle);
64 return rv;
65 }
66
WriteDataRaw(DataPipeProducerHandle data_pipe_producer,const void * elements,uint32_t * num_bytes,MojoWriteDataFlags flags)67 inline MojoResult WriteDataRaw(DataPipeProducerHandle data_pipe_producer,
68 const void* elements,
69 uint32_t* num_bytes,
70 MojoWriteDataFlags flags) {
71 return MojoWriteData(data_pipe_producer.value(), elements, num_bytes, flags);
72 }
73
BeginWriteDataRaw(DataPipeProducerHandle data_pipe_producer,void ** buffer,uint32_t * buffer_num_bytes,MojoWriteDataFlags flags)74 inline MojoResult BeginWriteDataRaw(DataPipeProducerHandle data_pipe_producer,
75 void** buffer,
76 uint32_t* buffer_num_bytes,
77 MojoWriteDataFlags flags) {
78 return MojoBeginWriteData(data_pipe_producer.value(), buffer,
79 buffer_num_bytes, flags);
80 }
81
EndWriteDataRaw(DataPipeProducerHandle data_pipe_producer,uint32_t num_bytes_written)82 inline MojoResult EndWriteDataRaw(DataPipeProducerHandle data_pipe_producer,
83 uint32_t num_bytes_written) {
84 return MojoEndWriteData(data_pipe_producer.value(), num_bytes_written);
85 }
86
ReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,void * elements,uint32_t * num_bytes,MojoReadDataFlags flags)87 inline MojoResult ReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,
88 void* elements,
89 uint32_t* num_bytes,
90 MojoReadDataFlags flags) {
91 return MojoReadData(data_pipe_consumer.value(), elements, num_bytes, flags);
92 }
93
BeginReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,const void ** buffer,uint32_t * buffer_num_bytes,MojoReadDataFlags flags)94 inline MojoResult BeginReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,
95 const void** buffer,
96 uint32_t* buffer_num_bytes,
97 MojoReadDataFlags flags) {
98 return MojoBeginReadData(data_pipe_consumer.value(), buffer, buffer_num_bytes,
99 flags);
100 }
101
EndReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,uint32_t num_bytes_read)102 inline MojoResult EndReadDataRaw(DataPipeConsumerHandle data_pipe_consumer,
103 uint32_t num_bytes_read) {
104 return MojoEndReadData(data_pipe_consumer.value(), num_bytes_read);
105 }
106
107 // A wrapper class that automatically creates a data pipe and owns both handles.
108 // TODO(vtl): Make an even more friendly version? (Maybe templatized for a
109 // particular type instead of some "element"? Maybe functions that take
110 // vectors?)
111 class DataPipe {
112 public:
113 DataPipe();
114 explicit DataPipe(const MojoCreateDataPipeOptions& options);
115 ~DataPipe();
116
117 ScopedDataPipeProducerHandle producer_handle;
118 ScopedDataPipeConsumerHandle consumer_handle;
119 };
120
DataPipe()121 inline DataPipe::DataPipe() {
122 MojoResult result MOJO_ALLOW_UNUSED =
123 CreateDataPipe(NULL, &producer_handle, &consumer_handle);
124 assert(result == MOJO_RESULT_OK);
125 }
126
DataPipe(const MojoCreateDataPipeOptions & options)127 inline DataPipe::DataPipe(const MojoCreateDataPipeOptions& options) {
128 MojoResult result MOJO_ALLOW_UNUSED =
129 CreateDataPipe(&options, &producer_handle, &consumer_handle);
130 assert(result == MOJO_RESULT_OK);
131 }
132
~DataPipe()133 inline DataPipe::~DataPipe() {
134 }
135
136 } // namespace mojo
137
138 #endif // MOJO_PUBLIC_CPP_SYSTEM_DATA_PIPE_H_
139