| // Copyright 2021 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // This file was automatically generated with: |
| // ../../ui/gfx/x/gen_xproto.py \ |
| // ../../third_party/xcbproto/src \ |
| // gen/ui/gfx/x \ |
| // bigreq \ |
| // composite \ |
| // damage \ |
| // dpms \ |
| // dri2 \ |
| // dri3 \ |
| // ge \ |
| // glx \ |
| // present \ |
| // randr \ |
| // record \ |
| // render \ |
| // res \ |
| // screensaver \ |
| // shape \ |
| // shm \ |
| // sync \ |
| // xc_misc \ |
| // xevie \ |
| // xf86dri \ |
| // xf86vidmode \ |
| // xfixes \ |
| // xinerama \ |
| // xinput \ |
| // xkb \ |
| // xprint \ |
| // xproto \ |
| // xselinux \ |
| // xtest \ |
| // xv \ |
| // xvmc |
| |
| #include "sync.h" |
| |
| #include <xcb/xcb.h> |
| #include <xcb/xcbext.h> |
| |
| #include "base/logging.h" |
| #include "base/posix/eintr_wrapper.h" |
| #include "ui/gfx/x/xproto_internal.h" |
| |
| namespace x11 { |
| |
| Sync::Sync(Connection* connection, const x11::QueryExtensionReply& info) |
| : connection_(connection), info_(info) {} |
| |
| std::string Sync::CounterError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "Sync::CounterError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_counter = " << static_cast<uint64_t>(bad_counter) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<Sync::CounterError>(Sync::CounterError* error_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_counter = (*error_).bad_counter; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_counter |
| Read(&bad_counter, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| std::string Sync::AlarmError::ToString() const { |
| std::stringstream ss_; |
| ss_ << "Sync::AlarmError{"; |
| ss_ << ".sequence = " << static_cast<uint64_t>(sequence) << ", "; |
| ss_ << ".bad_alarm = " << static_cast<uint64_t>(bad_alarm) << ", "; |
| ss_ << ".minor_opcode = " << static_cast<uint64_t>(minor_opcode) << ", "; |
| ss_ << ".major_opcode = " << static_cast<uint64_t>(major_opcode); |
| ss_ << "}"; |
| return ss_.str(); |
| } |
| |
| template <> |
| void ReadError<Sync::AlarmError>(Sync::AlarmError* error_, ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& sequence = (*error_).sequence; |
| auto& bad_alarm = (*error_).bad_alarm; |
| auto& minor_opcode = (*error_).minor_opcode; |
| auto& major_opcode = (*error_).major_opcode; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // error_code |
| uint8_t error_code; |
| Read(&error_code, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // bad_alarm |
| Read(&bad_alarm, &buf); |
| |
| // minor_opcode |
| Read(&minor_opcode, &buf); |
| |
| // major_opcode |
| Read(&major_opcode, &buf); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<Sync::CounterNotifyEvent>(Sync::CounterNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& kind = (*event_).kind; |
| auto& sequence = (*event_).sequence; |
| auto& counter = (*event_).counter; |
| auto& wait_value = (*event_).wait_value; |
| auto& counter_value = (*event_).counter_value; |
| auto& timestamp = (*event_).timestamp; |
| auto& count = (*event_).count; |
| auto& destroyed = (*event_).destroyed; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // kind |
| Read(&kind, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // counter |
| Read(&counter, &buf); |
| |
| // wait_value |
| { |
| auto& hi = wait_value.hi; |
| auto& lo = wait_value.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // counter_value |
| { |
| auto& hi = counter_value.hi; |
| auto& lo = counter_value.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // timestamp |
| Read(×tamp, &buf); |
| |
| // count |
| Read(&count, &buf); |
| |
| // destroyed |
| Read(&destroyed, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| void ReadEvent<Sync::AlarmNotifyEvent>(Sync::AlarmNotifyEvent* event_, |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| |
| auto& kind = (*event_).kind; |
| auto& sequence = (*event_).sequence; |
| auto& alarm = (*event_).alarm; |
| auto& counter_value = (*event_).counter_value; |
| auto& alarm_value = (*event_).alarm_value; |
| auto& timestamp = (*event_).timestamp; |
| auto& state = (*event_).state; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // kind |
| Read(&kind, &buf); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // alarm |
| Read(&alarm, &buf); |
| |
| // counter_value |
| { |
| auto& hi = counter_value.hi; |
| auto& lo = counter_value.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // alarm_value |
| { |
| auto& hi = alarm_value.hi; |
| auto& lo = alarm_value.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // timestamp |
| Read(×tamp, &buf); |
| |
| // state |
| uint8_t tmp0; |
| Read(&tmp0, &buf); |
| state = static_cast<Sync::Alarmstate>(tmp0); |
| |
| // pad0 |
| Pad(&buf, 3); |
| |
| DCHECK_LE(buf.offset, 32ul); |
| } |
| |
| Future<Sync::InitializeReply> Sync::Initialize( |
| const Sync::InitializeRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& desired_major_version = request.desired_major_version; |
| auto& desired_minor_version = request.desired_minor_version; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 0; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // desired_major_version |
| buf.Write(&desired_major_version); |
| |
| // desired_minor_version |
| buf.Write(&desired_minor_version); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<Sync::InitializeReply>( |
| &buf, "Sync::Initialize", false); |
| } |
| |
| Future<Sync::InitializeReply> Sync::Initialize( |
| const uint8_t& desired_major_version, |
| const uint8_t& desired_minor_version) { |
| return Sync::Initialize( |
| Sync::InitializeRequest{desired_major_version, desired_minor_version}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<Sync::InitializeReply> detail::ReadReply<Sync::InitializeReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<Sync::InitializeReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& major_version = (*reply).major_version; |
| auto& minor_version = (*reply).minor_version; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // major_version |
| Read(&major_version, &buf); |
| |
| // minor_version |
| Read(&minor_version, &buf); |
| |
| // pad1 |
| Pad(&buf, 22); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<Sync::ListSystemCountersReply> Sync::ListSystemCounters( |
| const Sync::ListSystemCountersRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 1; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<Sync::ListSystemCountersReply>( |
| &buf, "Sync::ListSystemCounters", false); |
| } |
| |
| Future<Sync::ListSystemCountersReply> Sync::ListSystemCounters() { |
| return Sync::ListSystemCounters(Sync::ListSystemCountersRequest{}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<Sync::ListSystemCountersReply> detail::ReadReply< |
| Sync::ListSystemCountersReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<Sync::ListSystemCountersReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| uint32_t counters_len{}; |
| auto& counters = (*reply).counters; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // counters_len |
| Read(&counters_len, &buf); |
| |
| // pad1 |
| Pad(&buf, 20); |
| |
| // counters |
| counters.resize(counters_len); |
| for (auto& counters_elem : counters) { |
| // counters_elem |
| { |
| auto& counter = counters_elem.counter; |
| auto& resolution = counters_elem.resolution; |
| uint16_t name_len{}; |
| auto& name = counters_elem.name; |
| |
| // counter |
| Read(&counter, &buf); |
| |
| // resolution |
| { |
| auto& hi = resolution.hi; |
| auto& lo = resolution.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // name_len |
| Read(&name_len, &buf); |
| |
| // name |
| name.resize(name_len); |
| for (auto& name_elem : name) { |
| // name_elem |
| Read(&name_elem, &buf); |
| } |
| |
| // pad0 |
| Align(&buf, 4); |
| } |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> Sync::CreateCounter(const Sync::CreateCounterRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& id = request.id; |
| auto& initial_value = request.initial_value; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 2; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // id |
| buf.Write(&id); |
| |
| // initial_value |
| { |
| auto& hi = initial_value.hi; |
| auto& lo = initial_value.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::CreateCounter", false); |
| } |
| |
| Future<void> Sync::CreateCounter(const Counter& id, |
| const Int64& initial_value) { |
| return Sync::CreateCounter(Sync::CreateCounterRequest{id, initial_value}); |
| } |
| |
| Future<void> Sync::DestroyCounter(const Sync::DestroyCounterRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& counter = request.counter; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 6; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // counter |
| buf.Write(&counter); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::DestroyCounter", false); |
| } |
| |
| Future<void> Sync::DestroyCounter(const Counter& counter) { |
| return Sync::DestroyCounter(Sync::DestroyCounterRequest{counter}); |
| } |
| |
| Future<Sync::QueryCounterReply> Sync::QueryCounter( |
| const Sync::QueryCounterRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& counter = request.counter; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 5; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // counter |
| buf.Write(&counter); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<Sync::QueryCounterReply>( |
| &buf, "Sync::QueryCounter", false); |
| } |
| |
| Future<Sync::QueryCounterReply> Sync::QueryCounter(const Counter& counter) { |
| return Sync::QueryCounter(Sync::QueryCounterRequest{counter}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<Sync::QueryCounterReply> detail::ReadReply< |
| Sync::QueryCounterReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<Sync::QueryCounterReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& counter_value = (*reply).counter_value; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // counter_value |
| { |
| auto& hi = counter_value.hi; |
| auto& lo = counter_value.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> Sync::Await(const Sync::AwaitRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& wait_list = request.wait_list; |
| size_t wait_list_len = wait_list.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 7; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // wait_list |
| DCHECK_EQ(static_cast<size_t>(wait_list_len), wait_list.size()); |
| for (auto& wait_list_elem : wait_list) { |
| // wait_list_elem |
| { |
| auto& trigger = wait_list_elem.trigger; |
| auto& event_threshold = wait_list_elem.event_threshold; |
| |
| // trigger |
| { |
| auto& counter = trigger.counter; |
| auto& wait_type = trigger.wait_type; |
| auto& wait_value = trigger.wait_value; |
| auto& test_type = trigger.test_type; |
| |
| // counter |
| buf.Write(&counter); |
| |
| // wait_type |
| uint32_t tmp1; |
| tmp1 = static_cast<uint32_t>(wait_type); |
| buf.Write(&tmp1); |
| |
| // wait_value |
| { |
| auto& hi = wait_value.hi; |
| auto& lo = wait_value.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| |
| // test_type |
| uint32_t tmp2; |
| tmp2 = static_cast<uint32_t>(test_type); |
| buf.Write(&tmp2); |
| } |
| |
| // event_threshold |
| { |
| auto& hi = event_threshold.hi; |
| auto& lo = event_threshold.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| } |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::Await", false); |
| } |
| |
| Future<void> Sync::Await(const std::vector<WaitCondition>& wait_list) { |
| return Sync::Await(Sync::AwaitRequest{wait_list}); |
| } |
| |
| Future<void> Sync::ChangeCounter(const Sync::ChangeCounterRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& counter = request.counter; |
| auto& amount = request.amount; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 4; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // counter |
| buf.Write(&counter); |
| |
| // amount |
| { |
| auto& hi = amount.hi; |
| auto& lo = amount.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::ChangeCounter", false); |
| } |
| |
| Future<void> Sync::ChangeCounter(const Counter& counter, const Int64& amount) { |
| return Sync::ChangeCounter(Sync::ChangeCounterRequest{counter, amount}); |
| } |
| |
| Future<void> Sync::SetCounter(const Sync::SetCounterRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& counter = request.counter; |
| auto& value = request.value; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 3; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // counter |
| buf.Write(&counter); |
| |
| // value |
| { |
| auto& hi = value.hi; |
| auto& lo = value.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::SetCounter", false); |
| } |
| |
| Future<void> Sync::SetCounter(const Counter& counter, const Int64& value) { |
| return Sync::SetCounter(Sync::SetCounterRequest{counter, value}); |
| } |
| |
| Future<void> Sync::CreateAlarm(const Sync::CreateAlarmRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& id = request.id; |
| ChangeAlarmAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 8; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // id |
| buf.Write(&id); |
| |
| // value_mask |
| SwitchVar(ChangeAlarmAttribute::Counter, value_list.counter.has_value(), true, |
| &value_mask); |
| SwitchVar(ChangeAlarmAttribute::ValueType, value_list.valueType.has_value(), |
| true, &value_mask); |
| SwitchVar(ChangeAlarmAttribute::Value, value_list.value.has_value(), true, |
| &value_mask); |
| SwitchVar(ChangeAlarmAttribute::TestType, value_list.testType.has_value(), |
| true, &value_mask); |
| SwitchVar(ChangeAlarmAttribute::Delta, value_list.delta.has_value(), true, |
| &value_mask); |
| SwitchVar(ChangeAlarmAttribute::Events, value_list.events.has_value(), true, |
| &value_mask); |
| uint32_t tmp3; |
| tmp3 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp3); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Counter)) { |
| auto& counter = *value_list.counter; |
| |
| // counter |
| buf.Write(&counter); |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::ValueType)) { |
| auto& valueType = *value_list.valueType; |
| |
| // valueType |
| uint32_t tmp4; |
| tmp4 = static_cast<uint32_t>(valueType); |
| buf.Write(&tmp4); |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Value)) { |
| auto& value = *value_list.value; |
| |
| // value |
| { |
| auto& hi = value.hi; |
| auto& lo = value.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::TestType)) { |
| auto& testType = *value_list.testType; |
| |
| // testType |
| uint32_t tmp5; |
| tmp5 = static_cast<uint32_t>(testType); |
| buf.Write(&tmp5); |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Delta)) { |
| auto& delta = *value_list.delta; |
| |
| // delta |
| { |
| auto& hi = delta.hi; |
| auto& lo = delta.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Events)) { |
| auto& events = *value_list.events; |
| |
| // events |
| buf.Write(&events); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::CreateAlarm", false); |
| } |
| |
| Future<void> Sync::CreateAlarm(const Alarm& id, |
| const absl::optional<Counter>& counter, |
| const absl::optional<Valuetype>& valueType, |
| const absl::optional<Int64>& value, |
| const absl::optional<Testtype>& testType, |
| const absl::optional<Int64>& delta, |
| const absl::optional<uint32_t>& events) { |
| return Sync::CreateAlarm(Sync::CreateAlarmRequest{ |
| id, counter, valueType, value, testType, delta, events}); |
| } |
| |
| Future<void> Sync::ChangeAlarm(const Sync::ChangeAlarmRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& id = request.id; |
| ChangeAlarmAttribute value_mask{}; |
| auto& value_list = request; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 9; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // id |
| buf.Write(&id); |
| |
| // value_mask |
| SwitchVar(ChangeAlarmAttribute::Counter, value_list.counter.has_value(), true, |
| &value_mask); |
| SwitchVar(ChangeAlarmAttribute::ValueType, value_list.valueType.has_value(), |
| true, &value_mask); |
| SwitchVar(ChangeAlarmAttribute::Value, value_list.value.has_value(), true, |
| &value_mask); |
| SwitchVar(ChangeAlarmAttribute::TestType, value_list.testType.has_value(), |
| true, &value_mask); |
| SwitchVar(ChangeAlarmAttribute::Delta, value_list.delta.has_value(), true, |
| &value_mask); |
| SwitchVar(ChangeAlarmAttribute::Events, value_list.events.has_value(), true, |
| &value_mask); |
| uint32_t tmp6; |
| tmp6 = static_cast<uint32_t>(value_mask); |
| buf.Write(&tmp6); |
| |
| // value_list |
| auto value_list_expr = value_mask; |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Counter)) { |
| auto& counter = *value_list.counter; |
| |
| // counter |
| buf.Write(&counter); |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::ValueType)) { |
| auto& valueType = *value_list.valueType; |
| |
| // valueType |
| uint32_t tmp7; |
| tmp7 = static_cast<uint32_t>(valueType); |
| buf.Write(&tmp7); |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Value)) { |
| auto& value = *value_list.value; |
| |
| // value |
| { |
| auto& hi = value.hi; |
| auto& lo = value.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::TestType)) { |
| auto& testType = *value_list.testType; |
| |
| // testType |
| uint32_t tmp8; |
| tmp8 = static_cast<uint32_t>(testType); |
| buf.Write(&tmp8); |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Delta)) { |
| auto& delta = *value_list.delta; |
| |
| // delta |
| { |
| auto& hi = delta.hi; |
| auto& lo = delta.lo; |
| |
| // hi |
| buf.Write(&hi); |
| |
| // lo |
| buf.Write(&lo); |
| } |
| } |
| if (CaseAnd(value_list_expr, ChangeAlarmAttribute::Events)) { |
| auto& events = *value_list.events; |
| |
| // events |
| buf.Write(&events); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::ChangeAlarm", false); |
| } |
| |
| Future<void> Sync::ChangeAlarm(const Alarm& id, |
| const absl::optional<Counter>& counter, |
| const absl::optional<Valuetype>& valueType, |
| const absl::optional<Int64>& value, |
| const absl::optional<Testtype>& testType, |
| const absl::optional<Int64>& delta, |
| const absl::optional<uint32_t>& events) { |
| return Sync::ChangeAlarm(Sync::ChangeAlarmRequest{ |
| id, counter, valueType, value, testType, delta, events}); |
| } |
| |
| Future<void> Sync::DestroyAlarm(const Sync::DestroyAlarmRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& alarm = request.alarm; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 11; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // alarm |
| buf.Write(&alarm); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::DestroyAlarm", false); |
| } |
| |
| Future<void> Sync::DestroyAlarm(const Alarm& alarm) { |
| return Sync::DestroyAlarm(Sync::DestroyAlarmRequest{alarm}); |
| } |
| |
| Future<Sync::QueryAlarmReply> Sync::QueryAlarm( |
| const Sync::QueryAlarmRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& alarm = request.alarm; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 10; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // alarm |
| buf.Write(&alarm); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<Sync::QueryAlarmReply>( |
| &buf, "Sync::QueryAlarm", false); |
| } |
| |
| Future<Sync::QueryAlarmReply> Sync::QueryAlarm(const Alarm& alarm) { |
| return Sync::QueryAlarm(Sync::QueryAlarmRequest{alarm}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<Sync::QueryAlarmReply> detail::ReadReply<Sync::QueryAlarmReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<Sync::QueryAlarmReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& trigger = (*reply).trigger; |
| auto& delta = (*reply).delta; |
| auto& events = (*reply).events; |
| auto& state = (*reply).state; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // trigger |
| { |
| auto& counter = trigger.counter; |
| auto& wait_type = trigger.wait_type; |
| auto& wait_value = trigger.wait_value; |
| auto& test_type = trigger.test_type; |
| |
| // counter |
| Read(&counter, &buf); |
| |
| // wait_type |
| uint32_t tmp9; |
| Read(&tmp9, &buf); |
| wait_type = static_cast<Sync::Valuetype>(tmp9); |
| |
| // wait_value |
| { |
| auto& hi = wait_value.hi; |
| auto& lo = wait_value.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // test_type |
| uint32_t tmp10; |
| Read(&tmp10, &buf); |
| test_type = static_cast<Sync::Testtype>(tmp10); |
| } |
| |
| // delta |
| { |
| auto& hi = delta.hi; |
| auto& lo = delta.lo; |
| |
| // hi |
| Read(&hi, &buf); |
| |
| // lo |
| Read(&lo, &buf); |
| } |
| |
| // events |
| Read(&events, &buf); |
| |
| // state |
| uint8_t tmp11; |
| Read(&tmp11, &buf); |
| state = static_cast<Sync::Alarmstate>(tmp11); |
| |
| // pad1 |
| Pad(&buf, 2); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> Sync::SetPriority(const Sync::SetPriorityRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& id = request.id; |
| auto& priority = request.priority; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 12; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // id |
| buf.Write(&id); |
| |
| // priority |
| buf.Write(&priority); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::SetPriority", false); |
| } |
| |
| Future<void> Sync::SetPriority(const uint32_t& id, const int32_t& priority) { |
| return Sync::SetPriority(Sync::SetPriorityRequest{id, priority}); |
| } |
| |
| Future<Sync::GetPriorityReply> Sync::GetPriority( |
| const Sync::GetPriorityRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& id = request.id; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 13; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // id |
| buf.Write(&id); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<Sync::GetPriorityReply>( |
| &buf, "Sync::GetPriority", false); |
| } |
| |
| Future<Sync::GetPriorityReply> Sync::GetPriority(const uint32_t& id) { |
| return Sync::GetPriority(Sync::GetPriorityRequest{id}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<Sync::GetPriorityReply> detail::ReadReply< |
| Sync::GetPriorityReply>(ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<Sync::GetPriorityReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& priority = (*reply).priority; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // priority |
| Read(&priority, &buf); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> Sync::CreateFence(const Sync::CreateFenceRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& drawable = request.drawable; |
| auto& fence = request.fence; |
| auto& initially_triggered = request.initially_triggered; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 14; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // drawable |
| buf.Write(&drawable); |
| |
| // fence |
| buf.Write(&fence); |
| |
| // initially_triggered |
| buf.Write(&initially_triggered); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::CreateFence", false); |
| } |
| |
| Future<void> Sync::CreateFence(const Drawable& drawable, |
| const Fence& fence, |
| const uint8_t& initially_triggered) { |
| return Sync::CreateFence( |
| Sync::CreateFenceRequest{drawable, fence, initially_triggered}); |
| } |
| |
| Future<void> Sync::TriggerFence(const Sync::TriggerFenceRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& fence = request.fence; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 15; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // fence |
| buf.Write(&fence); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::TriggerFence", false); |
| } |
| |
| Future<void> Sync::TriggerFence(const Fence& fence) { |
| return Sync::TriggerFence(Sync::TriggerFenceRequest{fence}); |
| } |
| |
| Future<void> Sync::ResetFence(const Sync::ResetFenceRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& fence = request.fence; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 16; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // fence |
| buf.Write(&fence); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::ResetFence", false); |
| } |
| |
| Future<void> Sync::ResetFence(const Fence& fence) { |
| return Sync::ResetFence(Sync::ResetFenceRequest{fence}); |
| } |
| |
| Future<void> Sync::DestroyFence(const Sync::DestroyFenceRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& fence = request.fence; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 17; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // fence |
| buf.Write(&fence); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::DestroyFence", false); |
| } |
| |
| Future<void> Sync::DestroyFence(const Fence& fence) { |
| return Sync::DestroyFence(Sync::DestroyFenceRequest{fence}); |
| } |
| |
| Future<Sync::QueryFenceReply> Sync::QueryFence( |
| const Sync::QueryFenceRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& fence = request.fence; |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 18; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // fence |
| buf.Write(&fence); |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<Sync::QueryFenceReply>( |
| &buf, "Sync::QueryFence", false); |
| } |
| |
| Future<Sync::QueryFenceReply> Sync::QueryFence(const Fence& fence) { |
| return Sync::QueryFence(Sync::QueryFenceRequest{fence}); |
| } |
| |
| template <> |
| COMPONENT_EXPORT(X11) |
| std::unique_ptr<Sync::QueryFenceReply> detail::ReadReply<Sync::QueryFenceReply>( |
| ReadBuffer* buffer) { |
| auto& buf = *buffer; |
| auto reply = std::make_unique<Sync::QueryFenceReply>(); |
| |
| auto& sequence = (*reply).sequence; |
| auto& triggered = (*reply).triggered; |
| |
| // response_type |
| uint8_t response_type; |
| Read(&response_type, &buf); |
| |
| // pad0 |
| Pad(&buf, 1); |
| |
| // sequence |
| Read(&sequence, &buf); |
| |
| // length |
| uint32_t length; |
| Read(&length, &buf); |
| |
| // triggered |
| Read(&triggered, &buf); |
| |
| // pad1 |
| Pad(&buf, 23); |
| |
| Align(&buf, 4); |
| DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length); |
| |
| return reply; |
| } |
| |
| Future<void> Sync::AwaitFence(const Sync::AwaitFenceRequest& request) { |
| if (!connection_->Ready() || !present()) |
| return {}; |
| |
| WriteBuffer buf; |
| |
| auto& fence_list = request.fence_list; |
| size_t fence_list_len = fence_list.size(); |
| |
| // major_opcode |
| uint8_t major_opcode = info_.major_opcode; |
| buf.Write(&major_opcode); |
| |
| // minor_opcode |
| uint8_t minor_opcode = 19; |
| buf.Write(&minor_opcode); |
| |
| // length |
| // Caller fills in length for writes. |
| Pad(&buf, sizeof(uint16_t)); |
| |
| // fence_list |
| DCHECK_EQ(static_cast<size_t>(fence_list_len), fence_list.size()); |
| for (auto& fence_list_elem : fence_list) { |
| // fence_list_elem |
| buf.Write(&fence_list_elem); |
| } |
| |
| Align(&buf, 4); |
| |
| return connection_->SendRequest<void>(&buf, "Sync::AwaitFence", false); |
| } |
| |
| Future<void> Sync::AwaitFence(const std::vector<Fence>& fence_list) { |
| return Sync::AwaitFence(Sync::AwaitFenceRequest{fence_list}); |
| } |
| |
| } // namespace x11 |