[Adaptation] Trigger OnThermalStateChange on adding a PeerConnection.

The OS mostly only generates OnThermalStateChange events when thermals
changes. Without this CL, PeerConnection that are created after such
event won't know what the thermal state is initially. This CL fixes that
so that PeerConnections can respond to poor thermal signals even if they
were created late.

By getting the current thermal state when the
PeerConnectionTrackerHost is constructed the host will never miss
reporting a thermal state to the PeerConnectionTracker.

By remembering the latest thermal state, the PeerConnectionTracker can
make sure to tell any PeerConnections that were added late what it is by
sending OnThermalStateChange as part of registration.

Bug: chromium:1098247
Change-Id: Id26e9d9f94f4d0c285b9466cb55e98f0bbce0c2c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2260552Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Henrik Boström <hbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#781728}

content/browser/renderer_host/media/peer_connection_tracker_host.cc

@@ -21,6 +21,13 @@ PeerConnectionTrackerHost::PeerConnectionTrackerHost(RenderProcessHost* rph)
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::PowerMonitor::AddObserver(this);
   rph->BindReceiver(tracker_.BindNewPipeAndPassReceiver());
+  // Ensure that the initial thermal state is known by the |tracker_|.
+  base::PowerObserver::DeviceThermalState initial_thermal_state =
+      base::PowerMonitor::GetCurrentThermalState();
+  if (initial_thermal_state !=
+      base::PowerObserver::DeviceThermalState::kUnknown) {
+    OnThermalStateChange(initial_thermal_state);
+  }
 }
 
 PeerConnectionTrackerHost::~PeerConnectionTrackerHost() {

third_party/blink/renderer/modules/peerconnection/peer_connection_tracker.cc

@@ -711,14 +711,11 @@ void PeerConnectionTracker::OnSuspend() {
 void PeerConnectionTracker::OnThermalStateChange(
     mojom::blink::DeviceThermalState thermal_state) {
   DCHECK_CALLED_ON_VALID_THREAD(main_thread_);
-  base::PowerObserver::DeviceThermalState state =
-      base::PowerObserver::DeviceThermalState::kUnknown;
-  mojo::EnumTraits<
-      mojom::blink::DeviceThermalState,
-      base::PowerObserver::DeviceThermalState>::FromMojom(thermal_state,
-                                                          &state);
+  mojo::EnumTraits<mojom::blink::DeviceThermalState,
+                   base::PowerObserver::DeviceThermalState>::
+      FromMojom(thermal_state, &current_thermal_state_);
   for (auto& entry : peer_connection_local_id_map_) {
-    entry.key->OnThermalStateChange(state);
+    entry.key->OnThermalStateChange(current_thermal_state_);
   }
 }
 
@@ -795,6 +792,11 @@ void PeerConnectionTracker::RegisterPeerConnection(
   peer_connection_tracker_host_->AddPeerConnection(std::move(info));
 
   peer_connection_local_id_map_.insert(pc_handler, lid);
+
+  if (current_thermal_state_ !=
+      base::PowerObserver::DeviceThermalState::kUnknown) {
+    pc_handler->OnThermalStateChange(current_thermal_state_);
+  }
 }
 
 void PeerConnectionTracker::UnregisterPeerConnection(

third_party/blink/renderer/modules/peerconnection/peer_connection_tracker.h

@@ -7,6 +7,7 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/power_monitor/power_observer.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -226,6 +227,8 @@ class MODULES_EXPORT PeerConnectionTracker
   FRIEND_TEST_ALL_PREFIXES(PeerConnectionTrackerTest, CreatingObject);
   FRIEND_TEST_ALL_PREFIXES(PeerConnectionTrackerTest, OnSuspend);
   FRIEND_TEST_ALL_PREFIXES(PeerConnectionTrackerTest, OnThermalStateChange);
+  FRIEND_TEST_ALL_PREFIXES(PeerConnectionTrackerTest,
+                           ReportInitialThermalState);
 
   explicit PeerConnectionTracker(
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner);
@@ -279,6 +282,8 @@ class MODULES_EXPORT PeerConnectionTracker
   // This map stores the local ID assigned to each RTCPeerConnectionHandler.
   typedef WTF::HashMap<RTCPeerConnectionHandler*, int> PeerConnectionLocalIdMap;
   PeerConnectionLocalIdMap peer_connection_local_id_map_;
+  base::PowerObserver::DeviceThermalState current_thermal_state_ =
+      base::PowerObserver::DeviceThermalState::kUnknown;
 
   // This keeps track of the next available local ID.
   int next_local_id_;

third_party/blink/renderer/modules/peerconnection/peer_connection_tracker_test.cc

@@ -226,6 +226,54 @@ TEST_F(PeerConnectionTrackerTest, OnThermalStateChange) {
   tracker_->OnThermalStateChange(blink::mojom::DeviceThermalState::kCritical);
 }
 
+TEST_F(PeerConnectionTrackerTest, ReportInitialThermalState) {
+  MockPeerConnectionHandler handler0;
+  MockPeerConnectionHandler handler1;
+  MockPeerConnectionHandler handler2;
+  CreateTrackerWithMocks();
+
+  // Nothing is reported by default.
+  EXPECT_CALL(handler0, OnThermalStateChange(_)).Times(0);
+  EXPECT_CALL(*mock_host_, AddPeerConnection(_)).Times(1);
+  tracker_->RegisterPeerConnection(
+      &handler0, webrtc::PeerConnectionInterface::RTCConfiguration(),
+      MediaConstraints(), nullptr);
+  base::RunLoop().RunUntilIdle();
+
+  // Report a known thermal state.
+  EXPECT_CALL(handler0, OnThermalStateChange(
+                            base::PowerObserver::DeviceThermalState::kNominal))
+      .Times(1);
+  tracker_->OnThermalStateChange(blink::mojom::DeviceThermalState::kNominal);
+
+  // Handlers registered late will get the event upon registering.
+  EXPECT_CALL(handler1, OnThermalStateChange(
+                            base::PowerObserver::DeviceThermalState::kNominal))
+      .Times(1);
+  EXPECT_CALL(*mock_host_, AddPeerConnection(_)).Times(1);
+  tracker_->RegisterPeerConnection(
+      &handler1, webrtc::PeerConnectionInterface::RTCConfiguration(),
+      MediaConstraints(), nullptr);
+  base::RunLoop().RunUntilIdle();
+
+  // Report the unknown thermal state.
+  EXPECT_CALL(handler0, OnThermalStateChange(
+                            base::PowerObserver::DeviceThermalState::kUnknown))
+      .Times(1);
+  EXPECT_CALL(handler1, OnThermalStateChange(
+                            base::PowerObserver::DeviceThermalState::kUnknown))
+      .Times(1);
+  tracker_->OnThermalStateChange(blink::mojom::DeviceThermalState::kUnknown);
+
+  // Handlers registered late get no event.
+  EXPECT_CALL(handler2, OnThermalStateChange(_)).Times(0);
+  EXPECT_CALL(*mock_host_, AddPeerConnection(_)).Times(1);
+  tracker_->RegisterPeerConnection(
+      &handler2, webrtc::PeerConnectionInterface::RTCConfiguration(),
+      MediaConstraints(), nullptr);
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_F(PeerConnectionTrackerTest, AddTransceiverWithOptionalValuesPresent) {
   CreateTrackerWithMocks();
   CreateAndRegisterPeerConnectionHandler();