Initial implementation of API WakeLock.

Source/modules/wake_lock/WakeLockController.cpp

Index: Source/modules/wake_lock/WakeLockController.cpp
diff --git a/Source/modules/wake_lock/WakeLockController.cpp b/Source/modules/wake_lock/WakeLockController.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f21a4bc9d328d555802a6f7c4efda3c100ceb60
--- /dev/null
+++ b/Source/modules/wake_lock/WakeLockController.cpp
@@ -0,0 +1,138 @@
+// Copyright 2014 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.
+
+#include "config.h"
+#include "modules/wake_lock/WakeLockController.h"
+
+#include "modules/wake_lock/WakeLockPromiseResolver.h"
+#include "public/platform/WebWakeLockClient.h"
+
+namespace blink {
+
+WakeLockController::WakeLockController(Page& page, WebWakeLockClient* client)
+    : PageLifecycleObserver(&page)
+    , m_client(client)
+{
+    m_lockCounter.resize(WebWakeLockNone + 1);

[mlamouri (slow - plz ping), 2014/08/18 12:15:53]

I'm not sure you need the +1, assuming you will not lock on "None". Also, given
the usage you are making of it, why not name this "WebWakeLockGuard"?

[redchenko, 2014/08/19 16:42:20]

Done.

+}
+
+WakeLockController::~WakeLockController()
+{
+}
+
+void WakeLockController::willBeDestroyed()
+{
+    if (m_client)
+        m_client->wakeLockDestroyed();
+}
+
+PassOwnPtrWillBeRawPtr<WakeLockController> WakeLockController::create(Page& page, WebWakeLockClient* client)
+{
+    return adoptPtrWillBeNoop(new WakeLockController(page, client));
+}
+
+void WakeLockController::resetClient()
+{
+    m_client = 0;
+}
+
+const char* WakeLockController::supplementName()
+{
+    return "WakeLockController";
+}
+
+WakeLockController* WakeLockController::from(Page* page)
+{
+    return static_cast<WakeLockController*>(WillBeHeapSupplement<Page>::from(page, supplementName()));
+}
+
+void WakeLockController::provideWakeLockTo(Page& page, WebWakeLockClient* client)
+{
+    WillBeHeapSupplement<Page>::provideTo(page, WakeLockController::supplementName(), WakeLockController::create(page, client));
+}
+
+void WakeLockController::trace(Visitor* visitor)
+{
+    WillBeHeapSupplement<Page>::trace(visitor);
+}
+
+ScriptPromise WakeLockController::requestWakeLock(ScriptState* state, WebWakeLockType type)
+{
+    return requestLockOrUnlock(state, type, true);
+}
+
+ScriptPromise WakeLockController::requestWakeUnlock(ScriptState* state, WebWakeLockType type)
+{
+    return requestLockOrUnlock(state, type, false);
+}
+
+bool WakeLockController::isHeld(WebWakeLockType type)
+{
+    return (m_lockCounter[type] > 0);
+}
+
+ScriptPromise WakeLockController::requestLockOrUnlock(ScriptState* state, WebWakeLockType type, bool lock)
+{
+    WakeLockPromiseResolverOwnPtr resolver = WakeLockPromiseResolver::create(state, type);
+    ScriptPromise promise = resolver->promise();
+    const int resolverId = resolver->id();
+
+    if (m_client) {
+        m_resolvers.append(resolver.release());
+        if (lock) {
+            m_client->requestWakeLock(type, resolverId,
+                blink::WebSecurityOrigin(context->securityOrigin()));
+        } else {
+            m_client->requestWakeUnlock(type, resolverId);
+        }
+    } else {
+        resolver->resolve();
+    }
+    return promise;
+}
+
+void WakeLockController::onCreatedWakeLockSuccessful(int resolverId)
+{
+    WebWakeLockType type = resolveOrRejectById(resolverId, true);
+    ++m_lockCounter[type];

[mlamouri (slow - plz ping), 2014/08/18 12:15:53]

Does that mean that we expect to handle multiple locks for the same frame? I
would expect that we would release when .release() is called regardless of the
number of times .request() was called before. In other words, .request() should
be a no-op if the lock is already held. We could take this into account and not
go all the way to the embedder in that case. The spec doesn't specify whether
the request should be rejected or resolved in that case. I believe it should be
resolved because the lock will happen FWIW.

[redchenko, 2014/08/19 16:42:20]

Done.

+}
+
+void WakeLockController::onCreatedWakeLockFailed(int resolverId)
+{
+    resolveOrRejectById(resolverId, false);
+}
+
+void WakeLockController::onUnlockedWakeLockSuccessful(int resolverId)
+{
+    WebWakeLockType type = resolveOrRejectById(resolverId, true);
+    if (m_lockCounter[type] > 0)
+        --m_lockCounter[type];
+}
+
+void WakeLockController::onUnlockedWakeLockFailed(int resolverId)
+{
+    resolveOrRejectById(resolverId, false);
+}
+
+WebWakeLockType WakeLockController::resolveOrRejectById(int resolverId, bool successful)
+{
+    for (Vector<WakeLockPromiseResolverOwnPtr>::iterator it = m_resolvers.begin();
+        it != m_resolvers.end();
+        ++it) {
+        WakeLockPromiseResolverOwnPtr& resolver = (*it);

[mlamouri (slow - plz ping), 2014/08/18 12:15:53]

nit: no need for the parenthesis.

[redchenko, 2014/08/19 16:42:20]

Done.

+        const WebWakeLockType type = resolver->type();
+        if (resolver->id() == resolverId) {
+            if (successful)
+                resolver->resolve();
+            else
+                resolver->reject();
+            m_resolvers.remove(it - m_resolvers.begin());
+            return type;
+        }
+    }
+    ASSERT_NOT_REACHED();
+    return WebWakeLockNone;
+}
+
+} // namespace WebCore