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
14namespace mojo {
15
16// DataPipeProducerHandle and DataPipeConsumerHandle ---------------------------
17
18class DataPipeProducerHandle : public Handle {
19 public:
20  DataPipeProducerHandle() {}
21  explicit DataPipeProducerHandle(MojoHandle value) : Handle(value) {}
22
23  // Copying and assignment allowed.
24};
25
26MOJO_COMPILE_ASSERT(sizeof(DataPipeProducerHandle) == sizeof(Handle),
27                    bad_size_for_cpp_DataPipeProducerHandle);
28
29typedef ScopedHandleBase<DataPipeProducerHandle> ScopedDataPipeProducerHandle;
30MOJO_COMPILE_ASSERT(sizeof(ScopedDataPipeProducerHandle) ==
31                        sizeof(DataPipeProducerHandle),
32                    bad_size_for_cpp_ScopedDataPipeProducerHandle);
33
34class DataPipeConsumerHandle : public Handle {
35 public:
36  DataPipeConsumerHandle() {}
37  explicit DataPipeConsumerHandle(MojoHandle value) : Handle(value) {}
38
39  // Copying and assignment allowed.
40};
41
42MOJO_COMPILE_ASSERT(sizeof(DataPipeConsumerHandle) == sizeof(Handle),
43                    bad_size_for_cpp_DataPipeConsumerHandle);
44
45typedef ScopedHandleBase<DataPipeConsumerHandle> ScopedDataPipeConsumerHandle;
46MOJO_COMPILE_ASSERT(sizeof(ScopedDataPipeConsumerHandle) ==
47                        sizeof(DataPipeConsumerHandle),
48                    bad_size_for_cpp_ScopedDataPipeConsumerHandle);
49
50inline 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
67inline 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
74inline 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
82inline MojoResult EndWriteDataRaw(DataPipeProducerHandle data_pipe_producer,
83                                  uint32_t num_bytes_written) {
84  return MojoEndWriteData(data_pipe_producer.value(), num_bytes_written);
85}
86
87inline 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
94inline 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
102inline 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?)
111class DataPipe {
112 public:
113  DataPipe();
114  explicit DataPipe(const MojoCreateDataPipeOptions& options);
115  ~DataPipe();
116
117  ScopedDataPipeProducerHandle producer_handle;
118  ScopedDataPipeConsumerHandle consumer_handle;
119};
120
121inline DataPipe::DataPipe() {
122  MojoResult result MOJO_ALLOW_UNUSED =
123      CreateDataPipe(NULL, &producer_handle, &consumer_handle);
124  assert(result == MOJO_RESULT_OK);
125}
126
127inline 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
133inline DataPipe::~DataPipe() {
134}
135
136}  // namespace mojo
137
138#endif  // MOJO_PUBLIC_CPP_SYSTEM_DATA_PIPE_H_
139