Release PowerSaveBlock on PeerConnection stop instead of removal

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>
@@ skipping 61 matching lines @@
   return value_.get();
 }
 
 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),
       weak_factory_(this) {
 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
 // build if WebRTC is disabled?
 #if defined(ENABLE_WEBRTC)
   audio_debug_recordings_file_path_ =
       GetContentClient()->browser()->GetDefaultDownloadDirectory();
   event_log_recordings_file_path_ = audio_debug_recordings_file_path_;
 
@@ skipping 28 matching lines @@
                                           const string& constraints) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   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);
+  dict->SetBoolean("isOpen", true);
 
   if (observers_.might_have_observers())
     SendUpdate("addPeerConnection", dict->CreateDeepCopy());
 
   peer_connection_data_.Append(std::move(dict));
+  ++num_open_connections_;
   CreateOrReleasePowerSaveBlocker();
 
   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);
   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;
 
+    MaybeClosePeerConnection(dict);
     peer_connection_data_.Remove(i, NULL);
-    CreateOrReleasePowerSaveBlocker();
 
     if (observers_.might_have_observers()) {
       std::unique_ptr<base::DictionaryValue> id(new base::DictionaryValue());
       id->SetInteger("pid", static_cast<int>(pid));
       id->SetInteger("lid", lid);
       SendUpdate("removePeerConnection", std::move(id));
     }
     break;
   }
 }
 
 void WebRTCInternals::OnUpdatePeerConnection(
     ProcessId pid, int lid, const string& type, const string& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
     base::DictionaryValue* record = NULL;
     peer_connection_data_.GetDictionary(i, &record);
 
     int this_pid = 0, this_lid = 0;
     record->GetInteger("pid", &this_pid);
     record->GetInteger("lid", &this_lid);
 
     if (this_pid != static_cast<int>(pid) || this_lid != lid)
       continue;
 
+    if (type == "stop") {
+      MaybeClosePeerConnection(record);
+    }
+
     // Append the update to the end of the log.
     base::ListValue* log = EnsureLogList(record);
     if (!log)
       return;
 
     std::unique_ptr<base::DictionaryValue> log_entry(
         new base::DictionaryValue());
 
     double epoch_time = base::Time::Now().ToJsTime();
     string time = base::DoubleToString(epoch_time);
@@ skipping 299 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   event_log_recordings_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance())
     i.GetCurrentValue()->StartWebRTCEventLog(event_log_recordings_file_path_);
 }
 #endif
 
+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();
+}
+
 void WebRTCInternals::CreateOrReleasePowerSaveBlocker() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!should_block_power_saving_)
     return;
 
-  if (peer_connection_data_.empty() && power_save_blocker_) {
+  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 (!peer_connection_data_.empty() && !power_save_blocker_) {
+  } else if (num_open_connections_ != 0 && !power_save_blocker_) {
     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)));
   }
 }
 
 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();
   }
 }
 
 }  // namespace content