Wake Lock API implementation (Blink part)

Source/core/dom/WakeLock.h

Index: Source/core/dom/WakeLock.h
diff --git a/Source/core/dom/WakeLock.h b/Source/core/dom/WakeLock.h
new file mode 100644
index 0000000000000000000000000000000000000000..fab2c3e2a0ebfcb4c8328a48aee7965ce053c656
--- /dev/null
+++ b/Source/core/dom/WakeLock.h
@@ -0,0 +1,59 @@
+// Copyright 2015 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.
+
+#ifndef WakeLock_h
+#define WakeLock_h
+
+#include "core/dom/DocumentLifecycleObserver.h"
+#include "core/dom/DocumentSupplementable.h"
+#include "core/dom/WakeLockController.h"
+#include "core/page/PageVisibilityState.h"
+#include "platform/heap/Handle.h"
+
+namespace blink {
+
+class Document;
+
+class WakeLock final
+    : public NoBaseWillBeGarbageCollectedFinalized<WakeLock>
+    , public DocumentSupplement

[mlamouri (slow - plz ping), 2015/04/28 08:00:25]

Hmmm, why do you have a Document supplement and a LocalFrame supplement. It
seems that only one of these would suffice, wouldn't it?

[alogvinov, 2015/04/28 16:34:25]

WakeLock stores the state of keepScreenAwake flag. It has to be Document
supplement, not LocalFrame supplement as a Document can have no frame. In the
latter case, keepScreenAwake state will obviously be ignored, but the variable
itself still exists so it needs to be stored somewhere. On the other hand,
WakeLockController is a bridge between WakeLock and WebWakeLockClient which is
obtained from WebFrameClient. In Chromium, WebWakeLockClient is implemented by
WakeLockDispatcher which sends wake lock requests to the corresponding
RenderFrameHost. It is thus reasonable to have WakeLockController supplement
LocalFrame.

[mlamouri (slow - plz ping), 2015/04/29 10:07:08]

Couldn't WakeLockDocument rely on the value stored in the frame and return a
default value if there are no frames? I believe that's a common pattern in
Document. For example, ::devicePixelRatio() does that or ::parentDocument().

[alogvinov, 2015/04/29 16:50:59]

Those properties are read-only. keepScreenAwake is writable, so it would be
confusing if a script writes one value and reads back another (the default one).

[mlamouri (slow - plz ping), 2015/04/30 13:15:38]

Fair point. Though, I wonder if we would be okay with that if it meant simpler
code. My understanding is that the behaviour of detached frames isn't really
important as long as it doesn't crash. I might be wrong though.

+    , public DocumentLifecycleObserver {
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(WakeLock);
+public:
+    static const char* supplementName();
+    static WakeLock& from(Document&);
+
+    static bool keepScreenAwake(Document&);
+    static void setKeepScreenAwake(Document&, bool);
+
+    // DocumentLifecycleObserver implementation
+    virtual void documentWasDetached() override;
+
+    DECLARE_VIRTUAL_TRACE();
+
+private:
+    class WakeLockDocumentVisibilityObserver;
+
+    explicit WakeLock(Document&);
+
+    void didChangeVisibilityState(PageVisibilityState);
+    void setKeepScreenAwake(bool);
+    void notifyController() const;
+
+    RawPtrWillBeMember<WakeLockController> m_controller;
+
+    // We need visibility observer as a member rather than as a base becasue
+    // when Oilpan is disabled, we need to be able to delete it before
+    // Document's destructor runs, as it asserts empty visibility observer list.
+    // This instance is owned by Document's base DocumentSupplementable, so
+    // it will be destroyed only after Document's destructor has finished.

[mlamouri (slow - plz ping), 2015/04/28 08:00:25]

I'm not sure I follow. How is HTMLCanvasElement doing it then?

[alogvinov, 2015/04/28 16:34:25]

HTMLCanvasElement is an HTMLElement, i.e. it is part of the DOM tree. It is
destroyed when the parent Document is detached, if I understand it correctly. So
when Oilpan is disabled, all elements are guaranteed to be deleted when
Document's dtor runs.

WakeLock is, on the other hand, a DocumentSupplement, so it owned not by
Document but by DocumentSupplementable, a Document's base. When Document's dtor
runs, DocumentSupplementable's dtor hasn't yet started (as it is a base), and
WakeLock is still alive. Had WakeLock implemented DocumentVisibilityObserver
itself, it would have been unregistered from Document in
DocumentVisibilityObserver's dtor. But as WakeLock is still alive, it would have
not been unregistered at this point, failing the assert in the Document's dtor.
unergisterObserver() is private in DocumentVisibilityObserver, so it cannot be
invoked separately from dtor either.

[mlamouri (slow - plz ping), 2015/04/29 10:07:08]

Ok. I see. Maybe we should have a way to clear the observing in the dtor. It
seems unfortunate to have to create this different object and add this
complexity.

+    OwnPtrWillBeMember<WakeLockDocumentVisibilityObserver> m_observer;
+
+    PageVisibilityState m_pageVisibilityState;
+    bool m_keepScreenAwake;
+};
+
+} // namespace blink
+
+#endif // WakeLock_h