class ManualWakeLease

This is probably not the implementation you're looking for, consider using

`WakeLeaseProvider`. `ManualWakeLease` may be appropriate if

`WakeLeaseProvider` does not fit your needs.

ManualWakeLease can be used to prevent the system from suspending. After a

call to `Start()` returns the system will keep running until after `End()`

is called or the instance is dropped. Users can use the same instance to

perform multiple atomic operations, for example by calling `Start()` after

`End()`.

If doing multiple atomic operations, a single `ManualWakeLease` can have

performance advantages over using a WakeLease directly because the

`ManualWakeLease` monitors system state over its lifetime, allowing it to

avoid certain operations vs a series of shorter-lived `WakeLease` instances.

Start an atomic operation. If `ActivityGovernor` protocol connection is

valid the system is guaranteed to stay running until `End()` is called or

this instance is dropped.

Returns `true` if one of the following is true:

* It was not necessary to take a SAG wake lease at this time because the

system is resumed

* A SAG wake lease was acquired

* A SAG wake lease was previously acquired

Returns `false` if it was necessary to acquire a SAG wake lease, but

an error occurred during acquisition. In this case, the `ManualWakeLease`

instance should be replaced with a new one.

Indicate that the operation is complete. The system may suspend after this

call is made. Calling `End()` makes sense in the case the caller wants to

use this instance to start a new atomic operation in the future. Returns

the wake lease currently currently held, if any.

Stores the SAG wake lease in the instance. The wake lease will be retained

until `End` or `TakeWakeLease` is called.

Consider whether End() is more appropriate for the use case.

Returns ZX_ERR_BAD_HANDLE if we don't currently have a wake lease.

IMPORTANT: This does not implicitly call `End()`, meaning that at the next

system transition to suspend, this class will take a SAG wake lease and

cause the suspend to abort.

Get a duplicate of the stored SAG wake lease. Returns ZX_ERR_BAD_HANDLE if

we don't currently have a wake lease.

fuchsia.power.system/SuspendBlocker implementation. This is used to avoid

creatingwake leases in cases where the system is resumed and `HandleInterrupt`

is called.