Wake Lock API implementation (Chromium part)

content/browser/wake_lock/wake_lock_service_context.cc

+// 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.
+
+#include "content/browser/wake_lock/wake_lock_service_context.h"
+
+#include "base/bind.h"
+#include "content/browser/power_save_blocker_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/power_save_blocker.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/common/service_registry.h"
+
+namespace content {
+
+WakeLockServiceContext::WakeLockServiceContext(WebContents* web_contents)
+    : WebContentsObserver(web_contents),
+      weak_factory_(this) {
+}
+
+WakeLockServiceContext::~WakeLockServiceContext() {
+}
+
+void WakeLockServiceContext::CreateService(
+    const RenderFrameHost* render_frame_host,
+    mojo::InterfaceRequest<WakeLockService> request) {
+  new WakeLockServiceImpl(weak_factory_.GetWeakPtr(),
+                          render_frame_host,
+                          request.Pass());
+}
+
+void WakeLockServiceContext::RenderFrameDeleted(

[nasko, 2015/09/03 17:53:37]

If you end up using FrameTreeNode ID, you can switch to FrameDeleted for
handling this case and not needing the RenderFrameHostChanged observer.

[alogvinov, 2015/09/04 15:39:26]

I'm afraid this is not the case. RenderFrameDeleted is additionally fired when
renderer process handling a subframe has died, which must remove wake lock
request for that frame. FrameDeleted is not fired in this case so it is
insufficient.

Also, RenderFrameHostChanged is needed to track render process change, i.e. when
navigating a subframe from same-process to cross-process. In fact,
WebContentsObserver documentation explicitly states that RenderFrameDeleted and
RenderFrameHostChanged is an appropriate combination to track the current set of
RenderFrameHosts.

[nasko, 2015/09/04 21:06:45]

For process crash, I totally agree we need RenderFrameDeleted.
Yes, while the documentation says that, the fact that tracking FrameTreeNode ids
is what the code now does, you don't need to care about cross-process
navigations. You conceptually care about frames, which is the FrameTreeNode
abstraction. FrameTreeNode ids are stable across process swap, so even when the
new RFH sends you a message, it will come from the same FrameTreeNode id.

Since you need to handle dropping the lock on navigation, you must already have
code that emits the right IPC. I should work in cross-process navigations in
addition to same-process ones, without the need for RenderFrameHostChanged.

+    RenderFrameHost* render_frame_host) {
+  CancelWakeLock(render_frame_host);
+}
+
+void WakeLockServiceContext::RenderFrameHostChanged(
+    RenderFrameHost* old_host,
+    RenderFrameHost* new_host) {
+  CancelWakeLock(old_host);
+}
+
+void WakeLockServiceContext::RequestWakeLock(
+    const RenderFrameHost* render_frame_host) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  frames_requesting_lock_.insert(render_frame_host);
+  UpdateWakeLock();
+}
+
+void WakeLockServiceContext::CancelWakeLock(
+    const RenderFrameHost* render_frame_host) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  frames_requesting_lock_.erase(render_frame_host);
+  UpdateWakeLock();
+}
+
+bool WakeLockServiceContext::HasWakeLockForTests() const {
+  return wake_lock_;
+}
+
+void WakeLockServiceContext::CreateWakeLock() {
+  DCHECK(!wake_lock_);
+  wake_lock_ = PowerSaveBlocker::Create(
+      PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
+      PowerSaveBlocker::kReasonOther,
+      "Wake Lock API");
+
+  // On Android, additionaly associate the blocker with this WebContents'
+  // NativeView.
+#if defined(OS_ANDROID)
+  DCHECK(web_contents());
+
+  static_cast<PowerSaveBlockerImpl*>(wake_lock_.get())->InitDisplaySleepBlocker(
+      web_contents());
+#endif
+}
+
+void WakeLockServiceContext::RemoveWakeLock() {
+  DCHECK(wake_lock_);
+  wake_lock_.reset();
+}
+
+void WakeLockServiceContext::UpdateWakeLock() {
+  if (!frames_requesting_lock_.empty()) {
+    if (!wake_lock_)
+      CreateWakeLock();
+  } else {
+    if (wake_lock_)
+      RemoveWakeLock();
+  }
+}
+
+}  // namespace content