power_manager/powerd/system/arc_timer_manager.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2018 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "power_manager/powerd/system/arc_timer_manager.h"

 #include <fcntl.h>
 #include <stdlib.h>
 #include <time.h>
 #include <unistd.h>

 #include <set>
 #include <utility>

 #include <base/bind.h>
 #include <base/check.h>
 #include <base/files/file.h>
 #include <base/memory/ptr_util.h>
 #include <base/posix/unix_domain_socket.h>
 #include <brillo/daemons/daemon.h>
 #include <components/timers/alarm_timer_chromeos.h>
 #include <chromeos/dbus/service_constants.h>
 #include <dbus/message.h>

 #include "power_manager/common/clock.h"

 namespace power_manager {
 namespace system {

 namespace {

 // Creates a new "invalid args" reply to |method_call|.
 std::unique_ptr<dbus::Response> CreateInvalidArgsError(
     dbus::MethodCall* method_call, const std::string& message) {
   return std::unique_ptr<dbus::Response>(dbus::ErrorResponse::FromMethodCall(
       method_call, DBUS_ERROR_INVALID_ARGS, message));
 }

 // Only wake up alarms are supported.
 bool IsSupportedClock(clockid_t clock_id) {
   return clock_id == CLOCK_BOOTTIME_ALARM || clock_id == CLOCK_REALTIME_ALARM;
 }

 // Expiration callback for timer of type |timer_id|. |expiration_fd| is the fd
 // to write to to indicate timer expiration to the instance.
 void OnExpiration(ArcTimerManager::TimerId timer_id, int expiration_fd) {
   DVLOG(1) << "Expiration callback for timer id=" << timer_id;
   // Write to the |expiration_fd| to indicate to the instance that the timer has
   // expired. The instance expects 8 bytes on the read end similar to what
   // happens on a timerfd expiration. The timerfd API expects this to be the
   // number of expirations, however, more than one expiration isn't tracked
   // currently. This can block in the unlikely scenario of multiple writes
   // happening but the instance not reading the data. When the send queue is
   // full (64Kb), a write attempt here will block.
   const uint64_t timer_data = 1;
   if (!base::UnixDomainSocket::SendMsg(
           expiration_fd, &timer_data, sizeof(timer_data), std::vector<int>())) {
     PLOG(ERROR) << "Failed to indicate timer expiration to the instance";
   }
 }

 // Writes |timer_ids| as an array of int32s to |writer|.
 void WriteTimerIdsToDBusResponse(
     const std::vector<ArcTimerManager::TimerId>& timer_ids,
     dbus::MessageWriter* writer) {
   dbus::MessageWriter array_writer(nullptr);
   writer->OpenArray("i", &array_writer);
   for (auto id : timer_ids)
     array_writer.AppendInt32(id);
   writer->CloseContainer(&array_writer);
 }

 }  // namespace

 ArcTimerManager::ArcTimerManager()
     : clock_(std::make_unique<Clock>()), weak_ptr_factory_(this) {}

 ArcTimerManager::~ArcTimerManager() = default;

 struct ArcTimerManager::ArcTimerInfo {
   ArcTimerInfo() = delete;
   ArcTimerInfo(ArcTimerInfo&&) = delete;
   ArcTimerInfo(clockid_t clock_id,
                base::ScopedFD expiration_fd,
                std::unique_ptr<timers::SimpleAlarmTimer> timer)
       : clock_id(clock_id),
         expiration_fd(std::move(expiration_fd)),
         timer(std::move(timer)) {}
   ArcTimerInfo(const ArcTimerInfo&) = delete;
   ArcTimerInfo& operator=(const ArcTimerInfo&) = delete;

   // Clock id associated with this timer.
   const clockid_t clock_id;

   // The file descriptor which will be written to when |timer| expires.
   const base::ScopedFD expiration_fd;

   // TODO(b/69759087): Make |SimpleAlarmTimer| take a clock id in its
   // constructor to create timers of different clock types.
   //
   // The timer that will be scheduled.
   const std::unique_ptr<timers::SimpleAlarmTimer> timer;
 };

 void ArcTimerManager::Init(DBusWrapperInterface* dbus_wrapper) {
   DCHECK(dbus_wrapper);
   dbus_wrapper->ExportMethod(kCreateArcTimersMethod,
                              base::Bind(&ArcTimerManager::HandleCreateArcTimers,
                                         weak_ptr_factory_.GetWeakPtr()));
   dbus_wrapper->ExportMethod(kStartArcTimerMethod,
                              base::Bind(&ArcTimerManager::HandleStartArcTimer,
                                         weak_ptr_factory_.GetWeakPtr()));
   dbus_wrapper->ExportMethod(kDeleteArcTimersMethod,
                              base::Bind(&ArcTimerManager::HandleDeleteArcTimers,
                                         weak_ptr_factory_.GetWeakPtr()));
 }

 std::vector<ArcTimerManager::TimerId> ArcTimerManager::GetTimerIdsForTesting(
     const std::string& tag) {
   auto it = client_timer_ids_.find(tag);
   if (it == client_timer_ids_.end())
     return std::vector<TimerId>();

   return it->second;
 }

 void ArcTimerManager::HandleCreateArcTimers(
     dbus::MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   DVLOG(1) << "CreateArcTimers";
   dbus::MessageReader reader(method_call);

   std::string tag;
   if (!reader.PopString(&tag)) {
     LOG(WARNING) << "Failed to pop tag string arg from "
                  << kCreateArcTimersMethod << " D-Bus method call";
     std::move(response_sender)
         .Run(CreateInvalidArgsError(method_call, "Expected tag string"));
     return;
   }
   DVLOG(1) << "Creating timers for tag=" << tag;

   dbus::MessageReader array_reader(nullptr);
   if (!reader.PopArray(&array_reader)) {
     LOG(WARNING) << "Failed to pop {clock id, expiration fd} array from "
                  << kCreateArcTimersMethod << " D-Bus method call";
     std::move(response_sender)
         .Run(CreateInvalidArgsError(
             method_call, "Expected array of clock id and descriptors"));
     return;
   }

   DeleteArcTimers(tag);

   // Iterate over the array of |clock_id, expiration_fd| and create an
   // |ArcTimerInfo| entry for each clock.
   std::vector<std::unique_ptr<ArcTimerInfo>> arc_timers =
       CreateArcTimers(&array_reader, is_testing_);
   if (arc_timers.size() == 0) {
     std::move(response_sender)
         .Run(CreateInvalidArgsError(method_call, "Failed to create timers"));
     return;
   }

   if (ContainsDuplicateClocks(arc_timers)) {
     std::move(response_sender)
         .Run(CreateInvalidArgsError(method_call,
                                     "Duplicate clocks not supported"));
     return;
   }

   // For each timer:
   // - Map an entry from a timer id to the timer.
   // - Push the timer id to the list of ids associated with the client's tag.
   // Newly generated ids guarantee that there are no key collisions in the first
   // operation. Earlier checks guarantee that there are no key collisions in the
   // second operation.
   for (auto& timer : arc_timers) {
     DVLOG(1) << "Adding tag=" << tag << " timer id=" << next_timer_id_;
     CHECK(timers_.emplace(next_timer_id_, std::move(timer)).second);
     client_timer_ids_[tag].push_back(next_timer_id_);
     next_timer_id_++;
   }

   std::unique_ptr<dbus::Response> response(
       dbus::Response::FromMethodCall(method_call));
   dbus::MessageWriter writer(response.get());
   WriteTimerIdsToDBusResponse(client_timer_ids_[tag], &writer);
   std::move(response_sender).Run(std::move(response));
 }

 // static:
 std::vector<std::unique_ptr<ArcTimerManager::ArcTimerInfo>>
 ArcTimerManager::CreateArcTimers(dbus::MessageReader* array_reader,
                                  bool create_for_testing) {
   std::vector<std::unique_ptr<ArcTimerInfo>> result;
   while (array_reader->HasMoreData()) {
     std::unique_ptr<ArcTimerInfo> arc_timer =
         CreateArcTimer(array_reader, create_for_testing);
     if (!arc_timer) {
       result.clear();
       return result;
     }
     result.push_back(std::move(arc_timer));
   }
   return result;
 }

 // static:
 std::unique_ptr<ArcTimerManager::ArcTimerInfo> ArcTimerManager::CreateArcTimer(
     dbus::MessageReader* array_reader, bool create_for_testing) {
   dbus::MessageReader struct_reader(nullptr);
   if (!array_reader->PopStruct(&struct_reader)) {
     LOG(WARNING) << "Failed to pop struct";
     return nullptr;
   }

   int32_t clock_id;
   if (!struct_reader.PopInt32(&clock_id)) {
     LOG(WARNING) << "Failed to pop clock id";
     return nullptr;
   }

   // The instance opens clocks of type CLOCK_BOOTTIME_ALARM and
   // CLOCK_REALTIME_ALARM. However, it uses only CLOCK_BOOTTIME_ALARM to set
   // wake up alarms. At this point, it's okay to pretend the host supports
   // CLOCK_REALTIME_ALARM instead of returning an error.
   if (!IsSupportedClock(static_cast<clockid_t>(clock_id))) {
     LOG(WARNING) << "Unsupported clock=" << clock_id;
     return nullptr;
   }

   base::ScopedFD expiration_fd;
   if (!struct_reader.PopFileDescriptor(&expiration_fd)) {
     LOG(WARNING) << "Failed to pop file descriptor for clock=" << clock_id;
     return nullptr;
   }
   if (!expiration_fd.is_valid()) {
     LOG(WARNING) << "Bad file descriptor for clock=" << clock_id;
     return nullptr;
   }

   if (create_for_testing) {
     return std::make_unique<ArcTimerInfo>(
         clock_id, std::move(expiration_fd),
         timers::SimpleAlarmTimer::CreateForTesting());
   }
   return std::make_unique<ArcTimerInfo>(clock_id, std::move(expiration_fd),
                                         timers::SimpleAlarmTimer::Create());
 }

 // static.
 bool ArcTimerManager::ContainsDuplicateClocks(
     const std::vector<std::unique_ptr<ArcTimerInfo>>& arc_timers) {
   std::set<clockid_t> seen_clock_ids;
   for (const auto& timer : arc_timers) {
     if (!seen_clock_ids.emplace(timer->clock_id).second)
       return true;
   }
   return false;
 }

 void ArcTimerManager::HandleStartArcTimer(
     dbus::MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   dbus::MessageReader reader(method_call);

   ArcTimerManager::TimerId timer_id;
   if (!reader.PopInt32(&timer_id)) {
     LOG(WARNING) << "Failed to pop timer id from " << kStartArcTimerMethod
                  << " D-Bus method call";
     std::move(response_sender)
         .Run(CreateInvalidArgsError(method_call, "Expected timer id"));
     return;
   }

   int64_t absolute_expiration_time_us;
   if (!reader.PopInt64(&absolute_expiration_time_us)) {
     LOG(WARNING) << "Failed to pop absolute expiration time from "
                  << kStartArcTimerMethod << " D-Bus method call";
     std::move(response_sender)
         .Run(CreateInvalidArgsError(method_call,
                                     "Expected absolute expiration time"));
     return;
   }
   base::TimeTicks absolute_expiration_time =
       base::TimeTicks() +
       base::TimeDelta::FromMicroseconds(absolute_expiration_time_us);

   // If a timer for the given clock is not created prior to this call then
   // return error. Else retrieve the timer associated with it.
   ArcTimerInfo* arc_timer = FindArcTimerInfo(timer_id);
   if (!arc_timer) {
     std::move(response_sender)
         .Run(CreateInvalidArgsError(
             method_call, "Invalid timer id " + std::to_string(timer_id)));
     return;
   }

   // Start the timer to expire at |absolute_expiration_time|. This call
   // automatically overrides the previous timer set.
   //
   // If the firing time has expired then set the timer to expire
   // immediately. The |current_time_ticks| should always include ticks spent
   // in sleep.
   base::TimeTicks current_time_ticks = clock_->GetCurrentBootTime();
   base::TimeDelta delay;
   if (absolute_expiration_time > current_time_ticks)
     delay = absolute_expiration_time - current_time_ticks;
   base::Time current_time = base::Time::Now();
   DVLOG(1) << "TimerId=" << timer_id << " CurrentTime=" << current_time
            << " NextAlarmAt=" << current_time + delay;
   // Pass the raw fd to write to when the timer expires. This is safe to do
   // because if the parent object goes away the timers are cleared and all
   // pending callbacks are cancelled. If the instance sets new timers after a
   // respawn, again, the old timers and pending callbacks are cancelled.
   // TODO(abhishekbh): This needs to be base::BindRepeating but it's not
   // available in the current version of libchrome.
   arc_timer->timer->Start(
       FROM_HERE, delay,
       base::Bind(&OnExpiration, timer_id, arc_timer->expiration_fd.get()));
   std::move(response_sender).Run(dbus::Response::FromMethodCall(method_call));
 }

 void ArcTimerManager::HandleDeleteArcTimers(
     dbus::MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   DVLOG(1) << "DeleteArcTimers";
   dbus::MessageReader reader(method_call);

   std::string tag;
   if (!reader.PopString(&tag)) {
     LOG(WARNING) << "Failed to pop tag string arg from "
                  << kDeleteArcTimersMethod << " D-Bus method call";
     std::move(response_sender)
         .Run(CreateInvalidArgsError(method_call, "Expected tag string"));
     return;
   }

   DeleteArcTimers(tag);
   std::move(response_sender).Run(dbus::Response::FromMethodCall(method_call));
 }

 void ArcTimerManager::DeleteArcTimers(const std::string& tag) {
   // Iterate over timer ids associated with |tag| and delete the timers
   // associated with each timer id.
   auto it = client_timer_ids_.find(tag);
   if (it == client_timer_ids_.end()) {
     DVLOG(1) << "Tag=" << tag << " not found";
     return;
   }

   DVLOG(1) << "Deleting timers for tag=" << tag;
   const auto& timer_ids = it->second;
   for (auto timer_id : timer_ids)
     timers_.erase(timer_id);
   client_timer_ids_.erase(it);
 }

 ArcTimerManager::ArcTimerInfo* ArcTimerManager::FindArcTimerInfo(
     ArcTimerManager::TimerId timer_id) {
   auto it = timers_.find(timer_id);
   return (it == timers_.end()) ? nullptr : it->second.get();
 }

 }  // namespace system
 }  // namespace power_manager
	// Copyright 2018 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "power_manager/powerd/system/arc_timer_manager.h"

	#include <fcntl.h>
	#include <stdlib.h>
	#include <time.h>
	#include <unistd.h>

	#include <set>
	#include <utility>

	#include <base/bind.h>
	#include <base/check.h>
	#include <base/files/file.h>
	#include <base/memory/ptr_util.h>
	#include <base/posix/unix_domain_socket.h>
	#include <brillo/daemons/daemon.h>
	#include <components/timers/alarm_timer_chromeos.h>
	#include <chromeos/dbus/service_constants.h>
	#include <dbus/message.h>

	#include "power_manager/common/clock.h"

	namespace power_manager {
	namespace system {

	namespace {

	// Creates a new "invalid args" reply to \|method_call\|.
	std::unique_ptr<dbus::Response> CreateInvalidArgsError(
	dbus::MethodCall* method_call, const std::string& message) {
	return std::unique_ptr<dbus::Response>(dbus::ErrorResponse::FromMethodCall(
	method_call, DBUS_ERROR_INVALID_ARGS, message));
	}

	// Only wake up alarms are supported.
	bool IsSupportedClock(clockid_t clock_id) {
	return clock_id == CLOCK_BOOTTIME_ALARM \|\| clock_id == CLOCK_REALTIME_ALARM;
	}

	// Expiration callback for timer of type \|timer_id\|. \|expiration_fd\| is the fd
	// to write to to indicate timer expiration to the instance.
	void OnExpiration(ArcTimerManager::TimerId timer_id, int expiration_fd) {
	DVLOG(1) << "Expiration callback for timer id=" << timer_id;
	// Write to the \|expiration_fd\| to indicate to the instance that the timer has
	// expired. The instance expects 8 bytes on the read end similar to what
	// happens on a timerfd expiration. The timerfd API expects this to be the
	// number of expirations, however, more than one expiration isn't tracked
	// currently. This can block in the unlikely scenario of multiple writes
	// happening but the instance not reading the data. When the send queue is
	// full (64Kb), a write attempt here will block.
	const uint64_t timer_data = 1;
	if (!base::UnixDomainSocket::SendMsg(
	expiration_fd, &timer_data, sizeof(timer_data), std::vector<int>())) {
	PLOG(ERROR) << "Failed to indicate timer expiration to the instance";
	}
	}

	// Writes \|timer_ids\| as an array of int32s to \|writer\|.
	void WriteTimerIdsToDBusResponse(
	const std::vector<ArcTimerManager::TimerId>& timer_ids,
	dbus::MessageWriter* writer) {
	dbus::MessageWriter array_writer(nullptr);
	writer->OpenArray("i", &array_writer);
	for (auto id : timer_ids)
	array_writer.AppendInt32(id);
	writer->CloseContainer(&array_writer);
	}

	} // namespace

	ArcTimerManager::ArcTimerManager()
	: clock_(std::make_unique<Clock>()), weak_ptr_factory_(this) {}

	ArcTimerManager::~ArcTimerManager() = default;

	struct ArcTimerManager::ArcTimerInfo {
	ArcTimerInfo() = delete;
	ArcTimerInfo(ArcTimerInfo&&) = delete;
	ArcTimerInfo(clockid_t clock_id,
	base::ScopedFD expiration_fd,
	std::unique_ptr<timers::SimpleAlarmTimer> timer)
	: clock_id(clock_id),
	expiration_fd(std::move(expiration_fd)),
	timer(std::move(timer)) {}
	ArcTimerInfo(const ArcTimerInfo&) = delete;
	ArcTimerInfo& operator=(const ArcTimerInfo&) = delete;

	// Clock id associated with this timer.
	const clockid_t clock_id;

	// The file descriptor which will be written to when \|timer\| expires.
	const base::ScopedFD expiration_fd;

	// TODO(b/69759087): Make \|SimpleAlarmTimer\| take a clock id in its
	// constructor to create timers of different clock types.
	//
	// The timer that will be scheduled.
	const std::unique_ptr<timers::SimpleAlarmTimer> timer;
	};

	void ArcTimerManager::Init(DBusWrapperInterface* dbus_wrapper) {
	DCHECK(dbus_wrapper);
	dbus_wrapper->ExportMethod(kCreateArcTimersMethod,
	base::Bind(&ArcTimerManager::HandleCreateArcTimers,
	weak_ptr_factory_.GetWeakPtr()));
	dbus_wrapper->ExportMethod(kStartArcTimerMethod,
	base::Bind(&ArcTimerManager::HandleStartArcTimer,
	weak_ptr_factory_.GetWeakPtr()));
	dbus_wrapper->ExportMethod(kDeleteArcTimersMethod,
	base::Bind(&ArcTimerManager::HandleDeleteArcTimers,
	weak_ptr_factory_.GetWeakPtr()));
	}

	std::vector<ArcTimerManager::TimerId> ArcTimerManager::GetTimerIdsForTesting(
	const std::string& tag) {
	auto it = client_timer_ids_.find(tag);
	if (it == client_timer_ids_.end())
	return std::vector<TimerId>();

	return it->second;
	}

	void ArcTimerManager::HandleCreateArcTimers(
	dbus::MethodCall* method_call,
	dbus::ExportedObject::ResponseSender response_sender) {
	DVLOG(1) << "CreateArcTimers";
	dbus::MessageReader reader(method_call);

	std::string tag;
	if (!reader.PopString(&tag)) {
	LOG(WARNING) << "Failed to pop tag string arg from "
	<< kCreateArcTimersMethod << " D-Bus method call";
	std::move(response_sender)
	.Run(CreateInvalidArgsError(method_call, "Expected tag string"));
	return;
	}
	DVLOG(1) << "Creating timers for tag=" << tag;

	dbus::MessageReader array_reader(nullptr);
	if (!reader.PopArray(&array_reader)) {
	LOG(WARNING) << "Failed to pop {clock id, expiration fd} array from "
	<< kCreateArcTimersMethod << " D-Bus method call";
	std::move(response_sender)
	.Run(CreateInvalidArgsError(
	method_call, "Expected array of clock id and descriptors"));
	return;
	}

	DeleteArcTimers(tag);

	// Iterate over the array of \|clock_id, expiration_fd\| and create an
	// \|ArcTimerInfo\| entry for each clock.
	std::vector<std::unique_ptr<ArcTimerInfo>> arc_timers =
	CreateArcTimers(&array_reader, is_testing_);
	if (arc_timers.size() == 0) {
	std::move(response_sender)
	.Run(CreateInvalidArgsError(method_call, "Failed to create timers"));
	return;
	}

	if (ContainsDuplicateClocks(arc_timers)) {
	std::move(response_sender)
	.Run(CreateInvalidArgsError(method_call,
	"Duplicate clocks not supported"));
	return;
	}

	// For each timer:
	// - Map an entry from a timer id to the timer.
	// - Push the timer id to the list of ids associated with the client's tag.
	// Newly generated ids guarantee that there are no key collisions in the first
	// operation. Earlier checks guarantee that there are no key collisions in the
	// second operation.
	for (auto& timer : arc_timers) {
	DVLOG(1) << "Adding tag=" << tag << " timer id=" << next_timer_id_;
	CHECK(timers_.emplace(next_timer_id_, std::move(timer)).second);
	client_timer_ids_[tag].push_back(next_timer_id_);
	next_timer_id_++;
	}

	std::unique_ptr<dbus::Response> response(
	dbus::Response::FromMethodCall(method_call));
	dbus::MessageWriter writer(response.get());
	WriteTimerIdsToDBusResponse(client_timer_ids_[tag], &writer);
	std::move(response_sender).Run(std::move(response));
	}

	// static:
	std::vector<std::unique_ptr<ArcTimerManager::ArcTimerInfo>>
	ArcTimerManager::CreateArcTimers(dbus::MessageReader* array_reader,
	bool create_for_testing) {
	std::vector<std::unique_ptr<ArcTimerInfo>> result;
	while (array_reader->HasMoreData()) {
	std::unique_ptr<ArcTimerInfo> arc_timer =
	CreateArcTimer(array_reader, create_for_testing);
	if (!arc_timer) {
	result.clear();
	return result;
	}
	result.push_back(std::move(arc_timer));
	}
	return result;
	}

	// static:
	std::unique_ptr<ArcTimerManager::ArcTimerInfo> ArcTimerManager::CreateArcTimer(
	dbus::MessageReader* array_reader, bool create_for_testing) {
	dbus::MessageReader struct_reader(nullptr);
	if (!array_reader->PopStruct(&struct_reader)) {
	LOG(WARNING) << "Failed to pop struct";
	return nullptr;
	}

	int32_t clock_id;
	if (!struct_reader.PopInt32(&clock_id)) {
	LOG(WARNING) << "Failed to pop clock id";
	return nullptr;
	}

	// The instance opens clocks of type CLOCK_BOOTTIME_ALARM and
	// CLOCK_REALTIME_ALARM. However, it uses only CLOCK_BOOTTIME_ALARM to set
	// wake up alarms. At this point, it's okay to pretend the host supports
	// CLOCK_REALTIME_ALARM instead of returning an error.
	if (!IsSupportedClock(static_cast<clockid_t>(clock_id))) {
	LOG(WARNING) << "Unsupported clock=" << clock_id;
	return nullptr;
	}

	base::ScopedFD expiration_fd;
	if (!struct_reader.PopFileDescriptor(&expiration_fd)) {
	LOG(WARNING) << "Failed to pop file descriptor for clock=" << clock_id;
	return nullptr;
	}
	if (!expiration_fd.is_valid()) {
	LOG(WARNING) << "Bad file descriptor for clock=" << clock_id;
	return nullptr;
	}

	if (create_for_testing) {
	return std::make_unique<ArcTimerInfo>(
	clock_id, std::move(expiration_fd),
	timers::SimpleAlarmTimer::CreateForTesting());
	}
	return std::make_unique<ArcTimerInfo>(clock_id, std::move(expiration_fd),
	timers::SimpleAlarmTimer::Create());
	}

	// static.
	bool ArcTimerManager::ContainsDuplicateClocks(
	const std::vector<std::unique_ptr<ArcTimerInfo>>& arc_timers) {
	std::set<clockid_t> seen_clock_ids;
	for (const auto& timer : arc_timers) {
	if (!seen_clock_ids.emplace(timer->clock_id).second)
	return true;
	}
	return false;
	}

	void ArcTimerManager::HandleStartArcTimer(
	dbus::MethodCall* method_call,
	dbus::ExportedObject::ResponseSender response_sender) {
	dbus::MessageReader reader(method_call);

	ArcTimerManager::TimerId timer_id;
	if (!reader.PopInt32(&timer_id)) {
	LOG(WARNING) << "Failed to pop timer id from " << kStartArcTimerMethod
	<< " D-Bus method call";
	std::move(response_sender)
	.Run(CreateInvalidArgsError(method_call, "Expected timer id"));
	return;
	}

	int64_t absolute_expiration_time_us;
	if (!reader.PopInt64(&absolute_expiration_time_us)) {
	LOG(WARNING) << "Failed to pop absolute expiration time from "
	<< kStartArcTimerMethod << " D-Bus method call";
	std::move(response_sender)
	.Run(CreateInvalidArgsError(method_call,
	"Expected absolute expiration time"));
	return;
	}
	base::TimeTicks absolute_expiration_time =
	base::TimeTicks() +
	base::TimeDelta::FromMicroseconds(absolute_expiration_time_us);

	// If a timer for the given clock is not created prior to this call then
	// return error. Else retrieve the timer associated with it.
	ArcTimerInfo* arc_timer = FindArcTimerInfo(timer_id);
	if (!arc_timer) {
	std::move(response_sender)
	.Run(CreateInvalidArgsError(
	method_call, "Invalid timer id " + std::to_string(timer_id)));
	return;
	}

	// Start the timer to expire at \|absolute_expiration_time\|. This call
	// automatically overrides the previous timer set.
	//
	// If the firing time has expired then set the timer to expire
	// immediately. The \|current_time_ticks\| should always include ticks spent
	// in sleep.
	base::TimeTicks current_time_ticks = clock_->GetCurrentBootTime();
	base::TimeDelta delay;
	if (absolute_expiration_time > current_time_ticks)
	delay = absolute_expiration_time - current_time_ticks;
	base::Time current_time = base::Time::Now();
	DVLOG(1) << "TimerId=" << timer_id << " CurrentTime=" << current_time
	<< " NextAlarmAt=" << current_time + delay;
	// Pass the raw fd to write to when the timer expires. This is safe to do
	// because if the parent object goes away the timers are cleared and all
	// pending callbacks are cancelled. If the instance sets new timers after a
	// respawn, again, the old timers and pending callbacks are cancelled.
	// TODO(abhishekbh): This needs to be base::BindRepeating but it's not
	// available in the current version of libchrome.
	arc_timer->timer->Start(
	FROM_HERE, delay,
	base::Bind(&OnExpiration, timer_id, arc_timer->expiration_fd.get()));
	std::move(response_sender).Run(dbus::Response::FromMethodCall(method_call));
	}

	void ArcTimerManager::HandleDeleteArcTimers(
	dbus::MethodCall* method_call,
	dbus::ExportedObject::ResponseSender response_sender) {
	DVLOG(1) << "DeleteArcTimers";
	dbus::MessageReader reader(method_call);

	std::string tag;
	if (!reader.PopString(&tag)) {
	LOG(WARNING) << "Failed to pop tag string arg from "
	<< kDeleteArcTimersMethod << " D-Bus method call";
	std::move(response_sender)
	.Run(CreateInvalidArgsError(method_call, "Expected tag string"));
	return;
	}

	DeleteArcTimers(tag);
	std::move(response_sender).Run(dbus::Response::FromMethodCall(method_call));
	}

	void ArcTimerManager::DeleteArcTimers(const std::string& tag) {
	// Iterate over timer ids associated with \|tag\| and delete the timers
	// associated with each timer id.
	auto it = client_timer_ids_.find(tag);
	if (it == client_timer_ids_.end()) {
	DVLOG(1) << "Tag=" << tag << " not found";
	return;
	}

	DVLOG(1) << "Deleting timers for tag=" << tag;
	const auto& timer_ids = it->second;
	for (auto timer_id : timer_ids)
	timers_.erase(timer_id);
	client_timer_ids_.erase(it);
	}

	ArcTimerManager::ArcTimerInfo* ArcTimerManager::FindArcTimerInfo(
	ArcTimerManager::TimerId timer_id) {
	auto it = timers_.find(timer_id);
	return (it == timers_.end()) ? nullptr : it->second.get();
	}

	} // namespace system
	} // namespace power_manager