| OLD | NEW |
|---|
| (Empty) |
| 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 "./math_calculator.h" | |
| 6 | |
| 7 #include "mojo/public/bindings/lib/message_builder.h" | |
| 8 #include "./math_calculator_internal.h" | |
| 9 | |
| 10 namespace math { | |
| 11 namespace { | |
| 12 | |
| 13 #pragma pack(push, 1) | |
| 14 #if defined(__clang__) | |
| 15 #pragma clang diagnostic push | |
| 16 #pragma clang diagnostic ignored "-Wunused-private-field" | |
| 17 #endif | |
| 18 const uint32_t kCalculator_Clear_Name = 0; | |
| 19 class Calculator_Clear_Params { | |
| 20 public: | |
| 21 static Calculator_Clear_Params* New(mojo::Buffer* buf) { | |
| 22 return new (buf->Allocate(sizeof(Calculator_Clear_Params))) | |
| 23 Calculator_Clear_Params(); | |
| 24 } | |
| 25 | |
| 26 | |
| 27 | |
| 28 | |
| 29 | |
| 30 private: | |
| 31 friend class mojo::internal::ObjectTraits<Calculator_Clear_Params>; | |
| 32 | |
| 33 Calculator_Clear_Params() { | |
| 34 _header_.num_bytes = sizeof(*this); | |
| 35 _header_.num_fields = 3; | |
| 36 } | |
| 37 | |
| 38 mojo::internal::StructHeader _header_; | |
| 39 | |
| 40 }; | |
| 41 MOJO_COMPILE_ASSERT(sizeof(Calculator_Clear_Params) == 8, | |
| 42 bad_sizeof_Calculator_Clear_Params); | |
| 43 | |
| 44 const uint32_t kCalculator_Add_Name = 1; | |
| 45 class Calculator_Add_Params { | |
| 46 public: | |
| 47 static Calculator_Add_Params* New(mojo::Buffer* buf) { | |
| 48 return new (buf->Allocate(sizeof(Calculator_Add_Params))) | |
| 49 Calculator_Add_Params(); | |
| 50 } | |
| 51 | |
| 52 void set_value(double value) { value_ = value; } | |
| 53 | |
| 54 double value() const { return value_; } | |
| 55 | |
| 56 private: | |
| 57 friend class mojo::internal::ObjectTraits<Calculator_Add_Params>; | |
| 58 | |
| 59 Calculator_Add_Params() { | |
| 60 _header_.num_bytes = sizeof(*this); | |
| 61 _header_.num_fields = 3; | |
| 62 } | |
| 63 | |
| 64 mojo::internal::StructHeader _header_; | |
| 65 double value_; | |
| 66 }; | |
| 67 MOJO_COMPILE_ASSERT(sizeof(Calculator_Add_Params) == 16, | |
| 68 bad_sizeof_Calculator_Add_Params); | |
| 69 | |
| 70 const uint32_t kCalculator_Multiply_Name = 2; | |
| 71 class Calculator_Multiply_Params { | |
| 72 public: | |
| 73 static Calculator_Multiply_Params* New(mojo::Buffer* buf) { | |
| 74 return new (buf->Allocate(sizeof(Calculator_Multiply_Params))) | |
| 75 Calculator_Multiply_Params(); | |
| 76 } | |
| 77 | |
| 78 void set_value(double value) { value_ = value; } | |
| 79 | |
| 80 double value() const { return value_; } | |
| 81 | |
| 82 private: | |
| 83 friend class mojo::internal::ObjectTraits<Calculator_Multiply_Params>; | |
| 84 | |
| 85 Calculator_Multiply_Params() { | |
| 86 _header_.num_bytes = sizeof(*this); | |
| 87 _header_.num_fields = 3; | |
| 88 } | |
| 89 | |
| 90 mojo::internal::StructHeader _header_; | |
| 91 double value_; | |
| 92 }; | |
| 93 MOJO_COMPILE_ASSERT(sizeof(Calculator_Multiply_Params) == 16, | |
| 94 bad_sizeof_Calculator_Multiply_Params); | |
| 95 | |
| 96 const uint32_t kCalculatorUI_Output_Name = 0; | |
| 97 class CalculatorUI_Output_Params { | |
| 98 public: | |
| 99 static CalculatorUI_Output_Params* New(mojo::Buffer* buf) { | |
| 100 return new (buf->Allocate(sizeof(CalculatorUI_Output_Params))) | |
| 101 CalculatorUI_Output_Params(); | |
| 102 } | |
| 103 | |
| 104 void set_value(double value) { value_ = value; } | |
| 105 | |
| 106 double value() const { return value_; } | |
| 107 | |
| 108 private: | |
| 109 friend class mojo::internal::ObjectTraits<CalculatorUI_Output_Params>; | |
| 110 | |
| 111 CalculatorUI_Output_Params() { | |
| 112 _header_.num_bytes = sizeof(*this); | |
| 113 _header_.num_fields = 3; | |
| 114 } | |
| 115 | |
| 116 mojo::internal::StructHeader _header_; | |
| 117 double value_; | |
| 118 }; | |
| 119 MOJO_COMPILE_ASSERT(sizeof(CalculatorUI_Output_Params) == 16, | |
| 120 bad_sizeof_CalculatorUI_Output_Params); | |
| 121 | |
| 122 #if defined(__clang__) | |
| 123 #pragma clang diagnostic pop | |
| 124 #endif | |
| 125 #pragma pack(pop) | |
| 126 | |
| 127 } // namespace | |
| 128 | |
| 129 | |
| 130 | |
| 131 CalculatorProxy::CalculatorProxy(mojo::MessageReceiver* receiver) | |
| 132 : receiver_(receiver) { | |
| 133 } | |
| 134 | |
| 135 void CalculatorProxy::Clear() { | |
| 136 size_t payload_size = | |
| 137 mojo::internal::Align(sizeof(Calculator_Clear_Params)); | |
| 138 | |
| 139 | |
| 140 mojo::MessageBuilder builder(kCalculator_Clear_Name, payload_size); | |
| 141 | |
| 142 Calculator_Clear_Params* params = | |
| 143 Calculator_Clear_Params::New(builder.buffer()); | |
| 144 | |
| 145 | |
| 146 | |
| 147 mojo::Message message; | |
| 148 mojo::internal::EncodePointersAndHandles(params, &message.handles); | |
| 149 | |
| 150 message.data = builder.Finish(); | |
| 151 | |
| 152 receiver_->Accept(&message); | |
| 153 } | |
| 154 | |
| 155 | |
| 156 void CalculatorProxy::Add(double value) { | |
| 157 size_t payload_size = | |
| 158 mojo::internal::Align(sizeof(Calculator_Add_Params)); | |
| 159 | |
| 160 | |
| 161 mojo::MessageBuilder builder(kCalculator_Add_Name, payload_size); | |
| 162 | |
| 163 Calculator_Add_Params* params = | |
| 164 Calculator_Add_Params::New(builder.buffer()); | |
| 165 | |
| 166 params->set_value(value); | |
| 167 | |
| 168 mojo::Message message; | |
| 169 mojo::internal::EncodePointersAndHandles(params, &message.handles); | |
| 170 | |
| 171 message.data = builder.Finish(); | |
| 172 | |
| 173 receiver_->Accept(&message); | |
| 174 } | |
| 175 | |
| 176 | |
| 177 void CalculatorProxy::Multiply(double value) { | |
| 178 size_t payload_size = | |
| 179 mojo::internal::Align(sizeof(Calculator_Multiply_Params)); | |
| 180 | |
| 181 | |
| 182 mojo::MessageBuilder builder(kCalculator_Multiply_Name, payload_size); | |
| 183 | |
| 184 Calculator_Multiply_Params* params = | |
| 185 Calculator_Multiply_Params::New(builder.buffer()); | |
| 186 | |
| 187 params->set_value(value); | |
| 188 | |
| 189 mojo::Message message; | |
| 190 mojo::internal::EncodePointersAndHandles(params, &message.handles); | |
| 191 | |
| 192 message.data = builder.Finish(); | |
| 193 | |
| 194 receiver_->Accept(&message); | |
| 195 } | |
| 196 | |
| 197 | |
| 198 bool CalculatorStub::Accept(mojo::Message* message) { | |
| 199 switch (message->data->header.name) { | |
| 200 case kCalculator_Clear_Name: { | |
| 201 Calculator_Clear_Params* params = | |
| 202 reinterpret_cast<Calculator_Clear_Params*>( | |
| 203 message->data->payload); | |
| 204 | |
| 205 if (!mojo::internal::DecodePointersAndHandles(params, *message)) | |
| 206 return false; | |
| 207 Clear(); | |
| 208 break; | |
| 209 } | |
| 210 | |
| 211 case kCalculator_Add_Name: { | |
| 212 Calculator_Add_Params* params = | |
| 213 reinterpret_cast<Calculator_Add_Params*>( | |
| 214 message->data->payload); | |
| 215 | |
| 216 if (!mojo::internal::DecodePointersAndHandles(params, *message)) | |
| 217 return false; | |
| 218 Add(params->value()); | |
| 219 break; | |
| 220 } | |
| 221 | |
| 222 case kCalculator_Multiply_Name: { | |
| 223 Calculator_Multiply_Params* params = | |
| 224 reinterpret_cast<Calculator_Multiply_Params*>( | |
| 225 message->data->payload); | |
| 226 | |
| 227 if (!mojo::internal::DecodePointersAndHandles(params, *message)) | |
| 228 return false; | |
| 229 Multiply(params->value()); | |
| 230 break; | |
| 231 } | |
| 232 | |
| 233 } | |
| 234 return true; | |
| 235 } | |
| 236 | |
| 237 | |
| 238 CalculatorUIProxy::CalculatorUIProxy(mojo::MessageReceiver* receiver) | |
| 239 : receiver_(receiver) { | |
| 240 } | |
| 241 | |
| 242 void CalculatorUIProxy::Output(double value) { | |
| 243 size_t payload_size = | |
| 244 mojo::internal::Align(sizeof(CalculatorUI_Output_Params)); | |
| 245 | |
| 246 | |
| 247 mojo::MessageBuilder builder(kCalculatorUI_Output_Name, payload_size); | |
| 248 | |
| 249 CalculatorUI_Output_Params* params = | |
| 250 CalculatorUI_Output_Params::New(builder.buffer()); | |
| 251 | |
| 252 params->set_value(value); | |
| 253 | |
| 254 mojo::Message message; | |
| 255 mojo::internal::EncodePointersAndHandles(params, &message.handles); | |
| 256 | |
| 257 message.data = builder.Finish(); | |
| 258 | |
| 259 receiver_->Accept(&message); | |
| 260 } | |
| 261 | |
| 262 | |
| 263 bool CalculatorUIStub::Accept(mojo::Message* message) { | |
| 264 switch (message->data->header.name) { | |
| 265 case kCalculatorUI_Output_Name: { | |
| 266 CalculatorUI_Output_Params* params = | |
| 267 reinterpret_cast<CalculatorUI_Output_Params*>( | |
| 268 message->data->payload); | |
| 269 | |
| 270 if (!mojo::internal::DecodePointersAndHandles(params, *message)) | |
| 271 return false; | |
| 272 Output(params->value()); | |
| 273 break; | |
| 274 } | |
| 275 | |
| 276 } | |
| 277 return true; | |
| 278 } | |
| 279 | |
| 280 | |
| 281 } // namespace math | |
| 282 | |
| 283 namespace mojo { | |
| 284 namespace internal { | |
| 285 | |
| 286 | |
| 287 | |
| 288 template <> | |
| 289 class ObjectTraits<math::Calculator_Clear_Params> { | |
| 290 public: | |
| 291 static void EncodePointersAndHandles( | |
| 292 math::Calculator_Clear_Params* params, | |
| 293 std::vector<Handle>* handles) { | |
| 294 | |
| 295 | |
| 296 } | |
| 297 | |
| 298 static bool DecodePointersAndHandles( | |
| 299 math::Calculator_Clear_Params* params, | |
| 300 const Message& message) { | |
| 301 | |
| 302 | |
| 303 return true; | |
| 304 } | |
| 305 }; | |
| 306 | |
| 307 template <> | |
| 308 class ObjectTraits<math::Calculator_Add_Params> { | |
| 309 public: | |
| 310 static void EncodePointersAndHandles( | |
| 311 math::Calculator_Add_Params* params, | |
| 312 std::vector<Handle>* handles) { | |
| 313 | |
| 314 | |
| 315 } | |
| 316 | |
| 317 static bool DecodePointersAndHandles( | |
| 318 math::Calculator_Add_Params* params, | |
| 319 const Message& message) { | |
| 320 | |
| 321 | |
| 322 return true; | |
| 323 } | |
| 324 }; | |
| 325 | |
| 326 template <> | |
| 327 class ObjectTraits<math::Calculator_Multiply_Params> { | |
| 328 public: | |
| 329 static void EncodePointersAndHandles( | |
| 330 math::Calculator_Multiply_Params* params, | |
| 331 std::vector<Handle>* handles) { | |
| 332 | |
| 333 | |
| 334 } | |
| 335 | |
| 336 static bool DecodePointersAndHandles( | |
| 337 math::Calculator_Multiply_Params* params, | |
| 338 const Message& message) { | |
| 339 | |
| 340 | |
| 341 return true; | |
| 342 } | |
| 343 }; | |
| 344 | |
| 345 template <> | |
| 346 class ObjectTraits<math::CalculatorUI_Output_Params> { | |
| 347 public: | |
| 348 static void EncodePointersAndHandles( | |
| 349 math::CalculatorUI_Output_Params* params, | |
| 350 std::vector<Handle>* handles) { | |
| 351 | |
| 352 | |
| 353 } | |
| 354 | |
| 355 static bool DecodePointersAndHandles( | |
| 356 math::CalculatorUI_Output_Params* params, | |
| 357 const Message& message) { | |
| 358 | |
| 359 | |
| 360 return true; | |
| 361 } | |
| 362 }; | |
| 363 | |
| 364 | |
| 365 } // namespace internal | |
| 366 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 68683010:
Mojo: Generate bindings from math_calculator.mojom. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src