Convert MediaWebContentsObsever to be the client of WakeLock mojo interface.

content/browser/media/media_web_contents_observer.cc

 // 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 "content/browser/media/media_web_contents_observer.h"
 
 #include <memory>
 
 #include "build/build_config.h"
 #include "content/browser/media/audible_metrics.h"
 #include "content/browser/media/audio_stream_monitor.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/media/media_player_delegate_messages.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
-#include "device/power_save_blocker/power_save_blocker.h"
 #include "ipc/ipc_message_macros.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
 
 namespace content {
 
 namespace {
 
 AudibleMetrics* GetAudibleMetrics() {
   static AudibleMetrics* metrics = new AudibleMetrics();
   return metrics;
 }
 
 }  // anonymous namespace
 
 MediaWebContentsObserver::MediaWebContentsObserver(WebContents* web_contents)
     : WebContentsObserver(web_contents),
+      has_audio_wake_lock_for_testing_(false),
+      has_video_wake_lock_for_testing_(false),
       session_controllers_manager_(this) {}
 
 MediaWebContentsObserver::~MediaWebContentsObserver() = default;
 
 void MediaWebContentsObserver::WebContentsDestroyed() {
   GetAudibleMetrics()->UpdateAudibleWebContentsState(web_contents(), false);
 }
 
 void MediaWebContentsObserver::RenderFrameDeleted(
     RenderFrameHost* render_frame_host) {
-  ClearPowerSaveBlockers(render_frame_host);
+  ClearWakeLocks(render_frame_host);
   session_controllers_manager_.RenderFrameDeleted(render_frame_host);
 
   if (fullscreen_player_ && fullscreen_player_->first == render_frame_host)
     fullscreen_player_.reset();
 }
 
 void MediaWebContentsObserver::MaybeUpdateAudibleState() {
   AudioStreamMonitor* audio_stream_monitor =
       static_cast<WebContentsImpl*>(web_contents())->audio_stream_monitor();
 
   if (audio_stream_monitor->WasRecentlyAudible()) {

[DaleCurtis, 2017/05/02 17:08:42]

{} not necessary for single-line if.

[ke.he, 2017/05/04 11:58:23]

Done.

-    if (!audio_power_save_blocker_)
-      CreateAudioPowerSaveBlocker();
+    LockAudio();
   } else {
-    audio_power_save_blocker_.reset();
+    CancelAudioLock();
   }
 
   GetAudibleMetrics()->UpdateAudibleWebContentsState(
       web_contents(), audio_stream_monitor->IsCurrentlyAudible());
 }
 
 bool MediaWebContentsObserver::HasActiveEffectivelyFullscreenVideo() const {
   if (!web_contents()->IsFullscreen() || !fullscreen_player_)
     return false;
 
@@ skipping 20 matching lines @@
                         OnMediaPlaying)
     IPC_MESSAGE_HANDLER(
         MediaPlayerDelegateHostMsg_OnMediaEffectivelyFullscreenChange,
         OnMediaEffectivelyFullscreenChange)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MediaWebContentsObserver::WasShown() {
-  // Restore power save blocker if there are active video players running.
-  if (!active_video_players_.empty() && !video_power_save_blocker_)
-    CreateVideoPowerSaveBlocker();
+  // Restore wake lock if there are active video players running.
+  if (!active_video_players_.empty()) {

[DaleCurtis, 2017/05/02 17:08:42]

Ditto

[ke.he, 2017/05/04 11:58:23]

Done.

+    LockVideo();
+  }
 }
 
 void MediaWebContentsObserver::WasHidden() {
   // If there are entities capturing screenshots or video (e.g., mirroring),
-  // don't release the power save blocker.
-  if (!web_contents()->GetCapturerCount())
-    video_power_save_blocker_.reset();
+  // don't release the wake lock.
+  if (!web_contents()->GetCapturerCount()) {
+    GetVideoWakeLock()->CancelWakeLock();

[DaleCurtis, 2017/05/02 17:08:42]

Put in CancelVideoLock() function like the audio one?

[ke.he, 2017/05/04 11:58:23]

Done.

+    has_video_wake_lock_for_testing_ = false;
+  }
 }
 
 void MediaWebContentsObserver::RequestPersistentVideo(bool value) {
   if (!fullscreen_player_)
     return;
 
   // The message is sent to the renderer even though the video is already the
   // fullscreen element itself. It will eventually be handled by Blink.
   Send(new MediaPlayerDelegateMsg_BecamePersistentVideo(
       fullscreen_player_->first->GetRoutingID(), fullscreen_player_->second,
       value));
 }
 
 void MediaWebContentsObserver::OnMediaDestroyed(
     RenderFrameHost* render_frame_host,
     int delegate_id) {
   OnMediaPaused(render_frame_host, delegate_id, true);
 }
 
 void MediaWebContentsObserver::OnMediaPaused(RenderFrameHost* render_frame_host,
                                              int delegate_id,
                                              bool reached_end_of_stream) {
   const MediaPlayerId player_id(render_frame_host, delegate_id);
   const bool removed_audio =
       RemoveMediaPlayerEntry(player_id, &active_audio_players_);
   const bool removed_video =
       RemoveMediaPlayerEntry(player_id, &active_video_players_);
-  MaybeReleasePowerSaveBlockers();
+  MaybeCancelVideoLock();
 
   if (removed_audio || removed_video) {
     // Notify observers the player has been "paused".
     static_cast<WebContentsImpl*>(web_contents())
         ->MediaStoppedPlaying(
             WebContentsObserver::MediaPlayerInfo(removed_video), player_id);
   }
 
   if (reached_end_of_stream)
     session_controllers_manager_.OnEnd(player_id);
@@ skipping 14 matching lines @@
   if (is_remote)
     return;
 
   const MediaPlayerId id(render_frame_host, delegate_id);
   if (has_audio)
     AddMediaPlayerEntry(id, &active_audio_players_);
 
   if (has_video) {
     AddMediaPlayerEntry(id, &active_video_players_);
 
-    // If we're not hidden and have just created a player, create a blocker.
-    if (!video_power_save_blocker_ &&
-        !static_cast<WebContentsImpl*>(web_contents())->IsHidden()) {
-      CreateVideoPowerSaveBlocker();
+    // If we're not hidden and have just created a player, create a wakelock.
+    if (!static_cast<WebContentsImpl*>(web_contents())->IsHidden()) {

[DaleCurtis, 2017/05/02 17:08:42]

no {} necessary.

[ke.he, 2017/05/04 11:58:23]

Done.

+      LockVideo();
     }
   }
 
   if (!session_controllers_manager_.RequestPlay(
           id, has_audio, is_remote, media_content_type)) {
     return;
   }
 
   // Notify observers of the new player.
   DCHECK(has_audio || has_video);
@@ skipping 10 matching lines @@
 
   if (!is_fullscreen) {
     if (fullscreen_player_ && *fullscreen_player_ == id)
       fullscreen_player_.reset();
     return;
   }
 
   fullscreen_player_ = id;
 }
 
-void MediaWebContentsObserver::ClearPowerSaveBlockers(
+void MediaWebContentsObserver::ClearWakeLocks(
     RenderFrameHost* render_frame_host) {
   std::set<MediaPlayerId> removed_players;
   RemoveAllMediaPlayerEntries(render_frame_host, &active_video_players_,
                               &removed_players);
   std::set<MediaPlayerId> video_players(removed_players);
   RemoveAllMediaPlayerEntries(render_frame_host, &active_audio_players_,
                               &removed_players);
-  MaybeReleasePowerSaveBlockers();
+  MaybeCancelVideoLock();
 
   // Notify all observers the player has been "paused".
   WebContentsImpl* wci = static_cast<WebContentsImpl*>(web_contents());
   for (const auto& id : removed_players) {
     auto it = video_players.find(id);
     bool was_video = (it != video_players.end());
     wci->MediaStoppedPlaying(WebContentsObserver::MediaPlayerInfo(was_video),
                              id);
   }
 }
 
-void MediaWebContentsObserver::CreateAudioPowerSaveBlocker() {
-  DCHECK(!audio_power_save_blocker_);
-  audio_power_save_blocker_.reset(new device::PowerSaveBlocker(
-      device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
-      device::PowerSaveBlocker::kReasonAudioPlayback, "Playing audio",
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
+device::mojom::WakeLockServicePtr&
+MediaWebContentsObserver::GetAudioWakeLock() {
+  // Here is a lazy binding, and will not reconnect after connection error.
+  if (!audio_wake_lock_) {

[DaleCurtis, 2017/05/02 17:08:42]

if (audio_wake_lock_) return audio_wake_lock_.get(); to avoid large indented
section.

+    device::mojom::WakeLockServiceRequest request =
+        mojo::MakeRequest(&audio_wake_lock_);

[DaleCurtis, 2017/05/02 17:08:42]

Inline into the call below?

[ke.he, 2017/05/04 11:58:23]

See comments below:)

+    device::mojom::WakeLockContext* wake_lock_context =

[DaleCurtis, 2017/05/02 17:08:42]

could be written:

if (auto* context = web_contents()->GetWakeLockContext()) {
 context->GetWakeLock(...);
}

That said, is it possible for the context to be null? See my comment below.

[ke.he, 2017/05/04 11:58:23]

It is safe that context to be null. the "mojo::MakeRequest(&audio_wake_lock_)"
is always called, this guarantees the "audio_wake_lock_.get()" is non-nullptr. 
In this situation, client is safe to use the audio_wake_lock_ to try the mojo
call, although it cannot connect the remote successfully.

+        web_contents()->GetWakeLockContext();
+    if (wake_lock_context) {
+      wake_lock_context->GetWakeLock(
+          device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
+          device::PowerSaveBlocker::kReasonAudioPlayback, "Playing audio",
+          std::move(request));
+    }
+  }
+  return audio_wake_lock_;

[DaleCurtis, 2017/05/02 17:08:42]

It's possible this will return nullptr if there's no context, yet none of the
other functions guard against it.

[ke.he, 2017/05/04 11:58:23]

The GetAudioWakeLock() never returns nullptr as comments above.

 }
 
-void MediaWebContentsObserver::CreateVideoPowerSaveBlocker() {
-  DCHECK(!video_power_save_blocker_);
-  DCHECK(!active_video_players_.empty());
-  video_power_save_blocker_.reset(new device::PowerSaveBlocker(
-      device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
-      device::PowerSaveBlocker::kReasonVideoPlayback, "Playing video",
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
-#if defined(OS_ANDROID)
-  if (web_contents()->GetNativeView()) {
-    video_power_save_blocker_.get()->InitDisplaySleepBlocker(
-        web_contents()->GetNativeView());
+device::mojom::WakeLockServicePtr&
+MediaWebContentsObserver::GetVideoWakeLock() {
+  // Here is a lazy binding, and will not reconnect after connection error.
+  if (!video_wake_lock_) {
+    device::mojom::WakeLockServiceRequest request =
+        mojo::MakeRequest(&video_wake_lock_);
+    device::mojom::WakeLockContext* wake_lock_context =
+        web_contents()->GetWakeLockContext();
+    if (wake_lock_context) {
+      wake_lock_context->GetWakeLock(
+          device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
+          device::PowerSaveBlocker::kReasonVideoPlayback, "Playing video",
+          std::move(request));
+    }
   }
-#endif
+  return video_wake_lock_;
 }
 
-void MediaWebContentsObserver::MaybeReleasePowerSaveBlockers() {
-  // If there are no more video players, clear the video power save blocker.
-  if (active_video_players_.empty())
-    video_power_save_blocker_.reset();
+void MediaWebContentsObserver::LockAudio() {
+  GetAudioWakeLock()->RequestWakeLock();
+  has_audio_wake_lock_for_testing_ = true;
+}
+
+void MediaWebContentsObserver::CancelAudioLock() {
+  GetAudioWakeLock()->CancelWakeLock();
+  has_audio_wake_lock_for_testing_ = false;
+}
+
+void MediaWebContentsObserver::LockVideo() {
+  DCHECK(!active_video_players_.empty());
+  GetVideoWakeLock()->RequestWakeLock();
+  has_video_wake_lock_for_testing_ = true;
+}
+
+void MediaWebContentsObserver::MaybeCancelVideoLock() {
+  // If there are no more video players, cancel the video wake lock.
+  if (active_video_players_.empty()) {
+    GetVideoWakeLock()->CancelWakeLock();
+    has_video_wake_lock_for_testing_ = false;
+  }
 }
 
 void MediaWebContentsObserver::AddMediaPlayerEntry(
     const MediaPlayerId& id,
     ActiveMediaPlayerMap* player_map) {
   (*player_map)[id.first].insert(id.second);
 }
 
 bool MediaWebContentsObserver::RemoveMediaPlayerEntry(
     const MediaPlayerId& id,
@@ skipping 22 matching lines @@
   if (it == player_map->end())
     return;
 
   for (int delegate_id : it->second)
     removed_players->insert(MediaPlayerId(render_frame_host, delegate_id));
 
   player_map->erase(it);
 }
 
 }  // namespace content