Convert //content/browser/media to be clients of WakeLock mojo service.

content/browser/media/capture/desktop_capture_device.cc

Index: content/browser/media/capture/desktop_capture_device.cc
diff --git a/content/browser/media/capture/desktop_capture_device.cc b/content/browser/media/capture/desktop_capture_device.cc
index f4236b5a2739897ab5eb7bb37768221869742b3d..96d5c76ca8ca99f473e2e6fbf16143e6eaf10ce9 100644
--- a/content/browser/media/capture/desktop_capture_device.cc
+++ b/content/browser/media/capture/desktop_capture_device.cc
@@ -26,9 +26,13 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "content/public/common/content_switches.h"
-#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 "device/wake_lock/public/interfaces/wake_lock_service.mojom.h"
 #include "media/base/video_util.h"
 #include "media/capture/content/capture_resolution_chooser.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "third_party/libyuv/include/libyuv/scale_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/cropping_window_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h"
@@ -62,6 +66,16 @@ bool IsFrameUnpackedOrInverted(webrtc::DesktopFrame* frame) {
       frame->size().width() * webrtc::DesktopFrame::kBytesPerPixel;
 }
 
+std::unique_ptr<service_manager::Connector> GetServiceConnector() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  service_manager::Connector* connector =
+      ServiceManagerConnection::GetForProcess()->GetConnector();
+
+  DCHECK(connector);
+  return connector->Clone();
+}
+
 }  // namespace
 
 #if defined(OS_WIN)
@@ -98,6 +112,9 @@ class DesktopCaptureDevice::Core : public webrtc::DesktopCapturer::Callback {
   // Captures a single frame.
   void DoCapture();
 
+  void BindAndRequestWakeLock(
+      std::unique_ptr<service_manager::Connector> connector);
+
   // Task runner used for capturing operations.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
@@ -140,9 +157,9 @@ class DesktopCaptureDevice::Core : public webrtc::DesktopCapturer::Callback {
 
   std::unique_ptr<webrtc::BasicDesktopFrame> black_frame_;
 
-  // TODO(jiayl): Remove power_save_blocker_ when there is an API to keep the
-  // screen from sleeping for the drive-by web.
-  std::unique_ptr<device::PowerSaveBlocker> power_save_blocker_;
+  device::mojom::WakeLockServicePtr wake_lock_;
+
+  base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
@@ -155,7 +172,8 @@ DesktopCaptureDevice::Core::Core(
       desktop_capturer_(std::move(capturer)),
       capture_in_progress_(false),
       first_capture_returned_(false),
-      capturer_type_(type) {}
+      capturer_type_(type),
+      weak_factory_(this) {}
 
 DesktopCaptureDevice::Core::~Core() {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ -181,11 +199,17 @@ void DesktopCaptureDevice::Core::AllocateAndStart(
       params.requested_format.frame_size,
       params.resolution_change_policy));
 
-  power_save_blocker_.reset(new device::PowerSaveBlocker(
-      device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
-      device::PowerSaveBlocker::kReasonOther, "DesktopCaptureDevice is running",
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
+  if (!wake_lock_) {

[Sergey Ulanov, 2017/05/17 18:47:55]

AllocateAndStart() is never called more than once, so I don't think you need
this check.

[ke.he, 2017/05/18 05:32:58]

Done.

+    // Gets a service_manager::Connector first, then binds the |wake_lock_|
+    // and requests a wake lock.
+    BrowserThread::PostTaskAndReplyWithResult(
+        BrowserThread::UI, FROM_HERE, base::BindOnce(&GetServiceConnector),
+        base::BindOnce(&DesktopCaptureDevice::Core::BindAndRequestWakeLock,
+                       weak_factory_.GetWeakPtr()));
+  } else {
+    // If |wake_lock_| is in bound already, request a wake lock directly.
+    wake_lock_->RequestWakeLock();
+  }
 
   desktop_capturer_->Start(this);
   // Assume it will be always started successfully for now.
@@ -364,6 +388,19 @@ void DesktopCaptureDevice::Core::DoCapture() {
   DCHECK(!capture_in_progress_);
 }
 
+void DesktopCaptureDevice::Core::BindAndRequestWakeLock(
+    std::unique_ptr<service_manager::Connector> 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, "Desktop capture is running",
+      mojo::MakeRequest(&wake_lock_));
+
+  wake_lock_->RequestWakeLock();
+}
+
 // static
 std::unique_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
     const DesktopMediaID& source) {
@@ -449,10 +486,8 @@ void DesktopCaptureDevice::SetNotificationWindowId(
   if (!core_)
     return;
   thread_.task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&Core::SetNotificationWindowId,
-                 base::Unretained(core_.get()),
-                 window_id));
+      FROM_HERE, base::Bind(&Core::SetNotificationWindowId,
+                            base::Unretained(core_.get()), window_id));
 }
 
 DesktopCaptureDevice::DesktopCaptureDevice(