Impose PowerSaveBlock while remoting content via Cast or WebRTC.

content/browser/media/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/media/webrtc_internals.h"
 
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/media/webrtc_internals_ui_observer.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/power_save_blocker.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 
 using base::ProcessId;
 using std::string;
 
 namespace content {
 
 namespace {
 // Makes sure that |dict| has a ListValue under path "log".
@@ skipping 50 matching lines @@
   if (!dict)
     return;
 
   dict->SetInteger("rid", render_process_id);
   dict->SetInteger("pid", static_cast<int>(pid));
   dict->SetInteger("lid", lid);
   dict->SetString("rtcConfiguration", rtc_configuration);
   dict->SetString("constraints", constraints);
   dict->SetString("url", url);
   peer_connection_data_.Append(dict);
+  CreateOrReleasePowerSaveBlocker();
 
   if (observers_.might_have_observers())
     SendUpdate("addPeerConnection", dict);
 }
 
 void WebRTCInternals::OnRemovePeerConnection(ProcessId pid, int lid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
     base::DictionaryValue* dict = NULL;
     peer_connection_data_.GetDictionary(i, &dict);
 
     int this_pid = 0;
     int this_lid = 0;
     dict->GetInteger("pid", &this_pid);
     dict->GetInteger("lid", &this_lid);
 
     if (this_pid != static_cast<int>(pid) || this_lid != lid)
       continue;
 
     peer_connection_data_.Remove(i, NULL);
+    CreateOrReleasePowerSaveBlocker();
 
     if (observers_.might_have_observers()) {
       base::DictionaryValue id;
       id.SetInteger("pid", static_cast<int>(pid));
       id.SetInteger("lid", lid);
       SendUpdate("removePeerConnection", &id);
     }
     break;
   }
 }
@@ skipping 141 matching lines @@
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->DisableAecDump();
   }
 #endif
 }
 
 void WebRTCInternals::ResetForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.Clear();
   peer_connection_data_.Clear();
+  CreateOrReleasePowerSaveBlocker();
   get_user_media_requests_.Clear();
   aec_dump_enabled_ = false;
 }
 
 void WebRTCInternals::SendUpdate(const string& command, base::Value* value) {
   DCHECK(observers_.might_have_observers());
 
   FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
                     observers_,
                     OnUpdate(command, value));
@@ skipping 16 matching lines @@
 #endif
 }
 
 void WebRTCInternals::FileSelectionCanceled(void* params) {
 #if defined(ENABLE_WEBRTC)
   SendUpdate("aecRecordingFileSelectionCancelled", NULL);
 #endif
 }
 
 void WebRTCInternals::OnRendererExit(int render_process_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   // Iterates from the end of the list to remove the PeerConnections created
   // by the exitting renderer.
   for (int i = peer_connection_data_.GetSize() - 1; i >= 0; --i) {
     base::DictionaryValue* record = NULL;
     peer_connection_data_.GetDictionary(i, &record);
 
     int this_rid = 0;
     record->GetInteger("rid", &this_rid);
 
     if (this_rid == render_process_id) {
       if (observers_.might_have_observers()) {
         int lid = 0, pid = 0;
         record->GetInteger("lid", &lid);
         record->GetInteger("pid", &pid);
 
         base::DictionaryValue update;
         update.SetInteger("lid", lid);
         update.SetInteger("pid", pid);
         SendUpdate("removePeerConnection", &update);
       }
       peer_connection_data_.Remove(i, NULL);
     }
   }
+  CreateOrReleasePowerSaveBlocker();
 
   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 15 matching lines @@
 void WebRTCInternals::EnableAecDumpOnAllRenderProcessHosts() {
   aec_dump_enabled_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->EnableAecDump(aec_dump_file_path_);
   }
 }
 #endif
 
+void WebRTCInternals::CreateOrReleasePowerSaveBlocker() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (peer_connection_data_.empty() && power_save_blocker_) {
+    DVLOG(1) << ("Releasing the block on application suspension since no "
+                 "PeerConnections are active anymore.");
+    power_save_blocker_.reset();
+  } else if (!peer_connection_data_.empty() && !power_save_blocker_) {
+    DVLOG(1) << ("Preventing the application from being suspended while one or "
+                 "more PeerConnections are active.");
+    power_save_blocker_ = content::PowerSaveBlocker::Create(
+        content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
+        "WebRTC has active PeerConnections.").Pass();
+  }
+}
+
 }  // namespace content