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

content/browser/media/capture/desktop_capture_device.cc

 // Copyright (c) 2013 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/media/capture/desktop_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #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"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
 namespace content {
 
@@ skipping 13 matching lines @@
       gfx::Size(source_size.width(), source_size.height()));
   return webrtc::DesktopRect::MakeLTRB(
       result.x(), result.y(), result.right(), result.bottom());
 }
 
 bool IsFrameUnpackedOrInverted(webrtc::DesktopFrame* frame) {
   return frame->stride() !=
       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)
 const base::Feature kDirectXCapturer{"DirectXCapturer",
                                      base::FEATURE_ENABLED_BY_DEFAULT};
 #endif
 
 class DesktopCaptureDevice::Core : public webrtc::DesktopCapturer::Callback {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
@@ skipping 16 matching lines @@
   // Method that is scheduled on |task_runner_| to be called on regular interval
   // to capture a frame.
   void OnCaptureTimer();
 
   // Captures a frame and schedules timer for the next one.
   void CaptureFrameAndScheduleNext();
 
   // 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_;
 
   // The underlying DesktopCapturer instance used to capture frames.
   std::unique_ptr<webrtc::DesktopCapturer> desktop_capturer_;
 
   // The device client which proxies device events to the controller. Accessed
   // on the task_runner_ thread.
   std::unique_ptr<Client> client_;
 
@@ skipping 22 matching lines @@
   bool first_capture_returned_;
 
   // The type of the capturer.
   DesktopMediaID::Type capturer_type_;
 
   // The system time when we receive the first frame.
   base::TimeTicks first_ref_time_;
 
   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);
 };
 
 DesktopCaptureDevice::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     std::unique_ptr<webrtc::DesktopCapturer> capturer,
     DesktopMediaID::Type type)
     : task_runner_(task_runner),
       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());
   client_.reset();
   output_frame_.reset();
   previous_frame_size_.set(0, 0);
   desktop_capturer_.reset();
 }
 
 void DesktopCaptureDevice::Core::AllocateAndStart(
     const media::VideoCaptureParams& params,
     std::unique_ptr<Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
   DCHECK_GT(params.requested_format.frame_rate, 0);
   DCHECK(desktop_capturer_);
   DCHECK(client);
   DCHECK(!client_);
 
   client_ = std::move(client);
   requested_frame_rate_ = params.requested_format.frame_rate;
   resolution_chooser_.reset(new media::CaptureResolutionChooser(
       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.
   client_->OnStarted();
 
   CaptureFrameAndScheduleNext();
 }
 
 void DesktopCaptureDevice::Core::SetNotificationWindowId(
     gfx::NativeViewId window_id) {
@@ skipping 158 matching lines @@
   DCHECK(!capture_in_progress_);
 
   capture_in_progress_ = true;
   desktop_capturer_->CaptureFrame();
 
   // Currently only synchronous implementations of DesktopCapturer are
   // supported.
   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) {
   webrtc::DesktopCaptureOptions options =
       webrtc::DesktopCaptureOptions::CreateDefault();
   // Leave desktop effects enabled during WebRTC captures.
   options.set_disable_effects(false);
 
 #if defined(OS_WIN)
   if (!base::FeatureList::IsEnabled(kDirectXCapturer)) {
@@ skipping 65 matching lines @@
     thread_.Stop();
   }
 }
 
 void DesktopCaptureDevice::SetNotificationWindowId(
     gfx::NativeViewId window_id) {
   // This may be called after the capturer has been stopped.
   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(
     std::unique_ptr<webrtc::DesktopCapturer> capturer,
     DesktopMediaID::Type type)
     : thread_("desktopCaptureThread") {
 #if defined(OS_WIN)
   // On Windows the thread must be a UI thread.
   base::MessageLoop::Type thread_type = base::MessageLoop::TYPE_UI;
 #else
   base::MessageLoop::Type thread_type = base::MessageLoop::TYPE_DEFAULT;
 #endif
 
   thread_.StartWithOptions(base::Thread::Options(thread_type, 0));
 
   core_.reset(new Core(thread_.task_runner(), std::move(capturer), type));
 }
 
 }  // namespace content