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

content/browser/webrtc/webrtc_internals.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/webrtc/webrtc_internals.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/browser/webrtc/webrtc_internals_ui_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.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 "ipc/ipc_platform_file.h"
 #include "media/audio/audio_manager.h"
 #include "media/media_features.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 #if defined(OS_WIN)
 #define IntToStringType base::IntToString16
 #else
 #define IntToStringType base::IntToString
 #endif
 
 using base::ProcessId;
 using std::string;
 
@@ skipping 49 matching lines @@
 WebRTCInternals::WebRTCInternals() : WebRTCInternals(500, true) {}
 
 WebRTCInternals::WebRTCInternals(int aggregate_updates_ms,
                                  bool should_block_power_saving)
     : audio_debug_recordings_(false),
       event_log_recordings_(false),
       selecting_event_log_(false),
       num_open_connections_(0),
       should_block_power_saving_(should_block_power_saving),
       aggregate_updates_ms_(aggregate_updates_ms),
+      has_wake_lock_for_testing_(false),
       weak_factory_(this) {
 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
 // build if WebRTC is disabled?
 #if BUILDFLAG(ENABLE_WEBRTC)
   audio_debug_recordings_file_path_ =
       GetContentClient()->browser()->GetDefaultDownloadDirectory();
   event_log_recordings_file_path_ = audio_debug_recordings_file_path_;
 
   if (audio_debug_recordings_file_path_.empty()) {
     // In this case the default path (|audio_debug_recordings_file_path_|) will
@@ skipping 36 matching lines @@
   dict->SetString("rtcConfiguration", rtc_configuration);
   dict->SetString("constraints", constraints);
   dict->SetString("url", url);
   dict->SetBoolean("isOpen", true);
 
   if (observers_.might_have_observers())
     SendUpdate("addPeerConnection", dict->CreateDeepCopy());
 
   peer_connection_data_.Append(std::move(dict));
   ++num_open_connections_;
-  CreateOrReleasePowerSaveBlocker();
+  UpdateWakeLock();
 
   if (render_process_id_set_.insert(render_process_id).second) {
     RenderProcessHost* host = RenderProcessHost::FromID(render_process_id);
     if (host)
       host->AddObserver(this);
   }
 }
 
 void WebRTCInternals::OnRemovePeerConnection(ProcessId pid, int lid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 297 matching lines @@
         std::unique_ptr<base::DictionaryValue> update(
             new base::DictionaryValue());
         update->SetInteger("lid", lid);
         update->SetInteger("pid", pid);
         SendUpdate("removePeerConnection", std::move(update));
       }
       MaybeClosePeerConnection(record);
       peer_connection_data_.Remove(i, NULL);
     }
   }
-  CreateOrReleasePowerSaveBlocker();
+  UpdateWakeLock();
 
   bool found_any = false;
   // Iterates from the end of the list to remove the getUserMedia requests
   // created by the exiting renderer.
   for (int i = get_user_media_requests_.GetSize() - 1; i >= 0; --i) {
     base::DictionaryValue* record = NULL;
     get_user_media_requests_.GetDictionary(i, &record);
 
     int this_rid = 0;
     record->GetInteger("rid", &this_rid);
@@ skipping 49 matching lines @@
 void WebRTCInternals::MaybeClosePeerConnection(base::DictionaryValue* record) {
   bool is_open;
   bool did_read = record->GetBoolean("isOpen", &is_open);
   DCHECK(did_read);
   if (!is_open)
     return;
 
   record->SetBoolean("isOpen", false);
   --num_open_connections_;
   DCHECK_GE(num_open_connections_, 0);
-  CreateOrReleasePowerSaveBlocker();
+  UpdateWakeLock();
 }
 
-void WebRTCInternals::CreateOrReleasePowerSaveBlocker() {
+void WebRTCInternals::UpdateWakeLock() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!should_block_power_saving_)
     return;
 
-  if (num_open_connections_ == 0 && power_save_blocker_) {
-    DVLOG(1) << ("Releasing the block on application suspension since no "
-                 "PeerConnections are active anymore.");
-    power_save_blocker_.reset();
-  } else if (num_open_connections_ != 0 && !power_save_blocker_) {
+  if (num_open_connections_ == 0) {
+    DVLOG(1)
+        << ("Cancel the wake lock on application suspension since no "
+            "PeerConnections are active anymore.");
+    GetWakeLock()->CancelWakeLock();
+    has_wake_lock_for_testing_ = false;
+  } else if (num_open_connections_ != 0) {
     DVLOG(1) << ("Preventing the application from being suspended while one or "
                  "more PeerConnections are active.");
-    power_save_blocker_.reset(new device::PowerSaveBlocker(
-        device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
-        device::PowerSaveBlocker::kReasonOther,
-        "WebRTC has active PeerConnections",
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
+    GetWakeLock()->RequestWakeLock();
+    has_wake_lock_for_testing_ = true;
   }
 }
 
+device::mojom::WakeLockService* WebRTCInternals::GetWakeLock() {
+  // 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::PreventAppSuspension,
+          device::mojom::WakeLockReason::ReasonOther,
+          "WebRTC has active PeerConnections", std::move(request));
+    }
+  }
+  return wake_lock_.get();
+}
+
 void WebRTCInternals::ProcessPendingUpdates() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   while (!pending_updates_.empty()) {
     const auto& update = pending_updates_.front();
     for (auto& observer : observers_)
       observer.OnUpdate(update.command(), update.value());
     pending_updates_.pop();
   }
 }
 
@@ skipping 13 matching lines @@
 
     if (this_pid == static_cast<int>(pid) && this_lid == lid) {
       if (index)
         *index = i;
       return record;
     }
   }
   return nullptr;
 }
 }  // namespace content