Use wakelock mojo interface instead of PowerSaveBlocker in renderer_host.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 87 matching lines @@
 
 #if defined(OS_ANDROID)
 #include "ui/android/view_android.h"
 #else
 #include "content/browser/compositor/image_transport_factory.h"
 // nogncheck as dependency of "ui/compositor" is on non-Android platforms only.
 #include "ui/compositor/compositor.h"  // nogncheck
 #endif
 
 #if defined(OS_MACOSX)
-#include "device/power_save_blocker/power_save_blocker.h"
+#include "content/public/common/service_manager_connection.h"
+#include "device/wake_lock/public/interfaces/wake_lock_provider.mojom.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using blink::WebDragOperation;
 using blink::WebDragOperationsMask;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
@@ skipping 1389 matching lines @@
     latency_info.AddLatencyNumber(ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT,
                                   0, id);
     Send(new ViewMsg_ForceRedraw(GetRoutingID(), latency_info));
     return;
   }
 
 #if defined(OS_MACOSX)
   // MacOS version of underlying GrabViewSnapshot() blocks while
   // display/GPU are in a power-saving mode, so make sure display
   // does not go to sleep for the duration of reading a snapshot.
-  if (pending_browser_snapshots_.empty()) {
-    DCHECK(!power_save_blocker_);
-    power_save_blocker_.reset(new device::PowerSaveBlocker(
-        device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
-        device::PowerSaveBlocker::kReasonOther, "GetSnapshot",
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
-  }
+  if (pending_browser_snapshots_.empty())
+    GetWakeLockService()->RequestWakeLock();
 #endif
   pending_browser_snapshots_.insert(std::make_pair(id, callback));
   ui::LatencyInfo latency_info;
   latency_info.AddLatencyNumber(ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT, 0,
                                 id);
   Send(new ViewMsg_ForceRedraw(GetRoutingID(), latency_info));
 }
 
 const NativeWebKeyboardEvent*
     RenderWidgetHostImpl::GetLastKeyboardEvent() const {
@@ skipping 936 matching lines @@
   while (it != pending_browser_snapshots_.end()) {
     if (it->first <= snapshot_id) {
       it->second.Run(image);
       pending_browser_snapshots_.erase(it++);
     } else {
       ++it;
     }
   }
 #if defined(OS_MACOSX)
   if (pending_browser_snapshots_.empty())
-    power_save_blocker_.reset();
+    GetWakeLockService()->CancelWakeLock();
 #endif
 }
 
 // static
 void RenderWidgetHostImpl::OnGpuSwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++) {
     std::set<RenderWidgetHostImpl*> rwhi_set;
     for (const auto& lc : latency_info[i].latency_components()) {
       if (lc.first.first == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
@@ skipping 149 matching lines @@
     std::vector<IPC::Message> messages) {
   RenderProcessHost* rph = GetProcess();
   for (std::vector<IPC::Message>::const_iterator i = messages.begin();
        i != messages.end(); ++i) {
     rph->OnMessageReceived(*i);
     if (i->dispatch_error())
       rph->OnBadMessageReceived(*i);
   }
 }
 
+#if defined(OS_MACOSX)
+device::mojom::WakeLockService* RenderWidgetHostImpl::GetWakeLockService() {
+  // Here is a lazy binding, and will not reconnect after connection error.
+  if (!wake_lock_) {
+    device::mojom::WakeLockServiceRequest request =
+        mojo::MakeRequest(&wake_lock_);
+    // In some testing contexts, the service manager connection isn't
+    // initialized.
+    if (ServiceManagerConnection::GetForProcess()) {
+      service_manager::Connector* connector =
+          ServiceManagerConnection::GetForProcess()->GetConnector();
+      DCHECK(connector);
+      device::mojom::WakeLockProviderPtr wake_lock_provider;
+      connector->BindInterface(device::mojom::kServiceName,
+                               mojo::MakeRequest(&wake_lock_provider));
+      wake_lock_provider->GetWakeLockWithoutContext(
+          device::mojom::WakeLockType::PreventDisplaySleep,
+          device::mojom::WakeLockReason::ReasonOther, "GetSnapshot",
+          std::move(request));
+    }
+  }
+  return wake_lock_.get();
+}
+#endif
+
 }  // namespace content