Make hbos per-file OWNER of *webrtc*browsertest* in chrome/browser/media/webrtc.

third_party/WebKit/Source/modules/peerconnection/RTCPeerConnectionTest.cpp

 // Copyright 2017 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 "modules/peerconnection/RTCPeerConnection.h"
 
 #include <string>
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 52 matching lines @@
     EXPECT_EQ("", GetExceptionMessage(scope));
   }
 
   void RemoveStream(V8TestingScope& scope,
                     RTCPeerConnection* pc,
                     MediaStream* stream) {
     pc->removeStream(stream, scope.GetExceptionState());
     EXPECT_EQ("", GetExceptionMessage(scope));
   }
 
-  MediaStreamTrack* GetTrack(RTCPeerConnection* pc,
-                             MediaStreamComponent* component) {
-    return pc->GetTrack(component);
-  }
-
  private:
   ScopedTestingPlatformSupport<TestingPlatformSupportWithWebRTC> platform;
 };
 
 TEST_F(RTCPeerConnectionTest, GetAudioTrack) {
   V8TestingScope scope;
   RTCPeerConnection* pc = CreatePC(scope);
   EXPECT_EQ("", GetExceptionMessage(scope));
   ASSERT_TRUE(pc);
 
   MediaStreamTrack* track =
       CreateTrack(scope, MediaStreamSource::kTypeAudio, "audioTrack");
   HeapVector<Member<MediaStreamTrack>> tracks;
   tracks.push_back(track);
   MediaStream* stream =
       MediaStream::Create(scope.GetExecutionContext(), tracks);
   ASSERT_TRUE(stream);
 
-  EXPECT_FALSE(GetTrack(pc, track->Component()));
+  EXPECT_FALSE(pc->GetTrack(track->Component()));
   AddStream(scope, pc, stream);
-  EXPECT_TRUE(GetTrack(pc, track->Component()));
+  EXPECT_TRUE(pc->GetTrack(track->Component()));
 }
 
 TEST_F(RTCPeerConnectionTest, GetVideoTrack) {
   V8TestingScope scope;
   RTCPeerConnection* pc = CreatePC(scope);
   EXPECT_EQ("", GetExceptionMessage(scope));
   ASSERT_TRUE(pc);
 
   MediaStreamTrack* track =
       CreateTrack(scope, MediaStreamSource::kTypeVideo, "videoTrack");
   HeapVector<Member<MediaStreamTrack>> tracks;
   tracks.push_back(track);
   MediaStream* stream =
       MediaStream::Create(scope.GetExecutionContext(), tracks);
   ASSERT_TRUE(stream);
 
-  EXPECT_FALSE(GetTrack(pc, track->Component()));
+  EXPECT_FALSE(pc->GetTrack(track->Component()));
   AddStream(scope, pc, stream);
-  EXPECT_TRUE(GetTrack(pc, track->Component()));
+  EXPECT_TRUE(pc->GetTrack(track->Component()));
 }
 
 TEST_F(RTCPeerConnectionTest, GetAudioAndVideoTrack) {
   V8TestingScope scope;
   RTCPeerConnection* pc = CreatePC(scope);
   EXPECT_EQ("", GetExceptionMessage(scope));
   ASSERT_TRUE(pc);
 
   HeapVector<Member<MediaStreamTrack>> tracks;
   MediaStreamTrack* audio_track =
       CreateTrack(scope, MediaStreamSource::kTypeAudio, "audioTrack");
   tracks.push_back(audio_track);
   MediaStreamTrack* video_track =
       CreateTrack(scope, MediaStreamSource::kTypeVideo, "videoTrack");
   tracks.push_back(video_track);
 
   MediaStream* stream =
       MediaStream::Create(scope.GetExecutionContext(), tracks);
   ASSERT_TRUE(stream);
 
-  EXPECT_FALSE(GetTrack(pc, audio_track->Component()));
-  EXPECT_FALSE(GetTrack(pc, video_track->Component()));
+  EXPECT_FALSE(pc->GetTrack(audio_track->Component()));
+  EXPECT_FALSE(pc->GetTrack(video_track->Component()));
   AddStream(scope, pc, stream);
-  EXPECT_TRUE(GetTrack(pc, audio_track->Component()));
-  EXPECT_TRUE(GetTrack(pc, video_track->Component()));
+  EXPECT_TRUE(pc->GetTrack(audio_track->Component()));
+  EXPECT_TRUE(pc->GetTrack(video_track->Component()));
 }
 
 TEST_F(RTCPeerConnectionTest, GetTrackRemoveStreamAndGCAll) {
   V8TestingScope scope;
   Persistent<RTCPeerConnection> pc = CreatePC(scope);
   EXPECT_EQ("", GetExceptionMessage(scope));
   ASSERT_TRUE(pc);
 
   MediaStreamTrack* track =
       CreateTrack(scope, MediaStreamSource::kTypeAudio, "audioTrack");
   HeapVector<Member<MediaStreamTrack>> tracks;
   tracks.push_back(track);
   MediaStream* stream =
       MediaStream::Create(scope.GetExecutionContext(), tracks);
   ASSERT_TRUE(stream);
 
   MediaStreamComponent* track_component = track->Component();
 
-  EXPECT_FALSE(GetTrack(pc, track_component));
+  EXPECT_FALSE(pc->GetTrack(track_component));
   AddStream(scope, pc, stream);
-  EXPECT_TRUE(GetTrack(pc, track_component));
+  EXPECT_TRUE(pc->GetTrack(track_component));
 
   RemoveStream(scope, pc, stream);
   // This will destroy |MediaStream|, |MediaStreamTrack| and its
   // |MediaStreamComponent|, which will remove its mapping from the peer
   // connection.
   WebHeap::CollectAllGarbageForTesting();
-  EXPECT_FALSE(GetTrack(pc, track_component));
+  EXPECT_FALSE(pc->GetTrack(track_component));
 }
 
 TEST_F(RTCPeerConnectionTest,
        GetTrackRemoveStreamAndGCWithPersistentComponent) {
   V8TestingScope scope;
   Persistent<RTCPeerConnection> pc = CreatePC(scope);
   EXPECT_EQ("", GetExceptionMessage(scope));
   ASSERT_TRUE(pc);
 
   MediaStreamTrack* track =
       CreateTrack(scope, MediaStreamSource::kTypeAudio, "audioTrack");
   HeapVector<Member<MediaStreamTrack>> tracks;
   tracks.push_back(track);
   MediaStream* stream =
       MediaStream::Create(scope.GetExecutionContext(), tracks);
   ASSERT_TRUE(stream);
 
   Persistent<MediaStreamComponent> track_component = track->Component();
 
-  EXPECT_FALSE(GetTrack(pc, track_component));
+  EXPECT_FALSE(pc->GetTrack(track_component.Get()));
   AddStream(scope, pc, stream);
-  EXPECT_TRUE(GetTrack(pc, track_component));
+  EXPECT_TRUE(pc->GetTrack(track_component.Get()));
 
   RemoveStream(scope, pc, stream);
   // This will destroy |MediaStream| and |MediaStreamTrack| (but not
   // |MediaStreamComponent|), which will remove its mapping from the peer
   // connection.
   WebHeap::CollectAllGarbageForTesting();
-  EXPECT_FALSE(GetTrack(pc, track_component));
+  EXPECT_FALSE(pc->GetTrack(track_component.Get()));
 }
 
 TEST_F(RTCPeerConnectionTest, GetTrackRemoveStreamAndGCWithPersistentStream) {
   V8TestingScope scope;
   Persistent<RTCPeerConnection> pc = CreatePC(scope);
   EXPECT_EQ("", GetExceptionMessage(scope));
   ASSERT_TRUE(pc);
 
   MediaStreamTrack* track =
       CreateTrack(scope, MediaStreamSource::kTypeAudio, "audioTrack");
   HeapVector<Member<MediaStreamTrack>> tracks;
   tracks.push_back(track);
   Persistent<MediaStream> stream =
       MediaStream::Create(scope.GetExecutionContext(), tracks);
   ASSERT_TRUE(stream);
 
   MediaStreamComponent* track_component = track->Component();
 
-  EXPECT_FALSE(GetTrack(pc, track_component));
+  EXPECT_FALSE(pc->GetTrack(track_component));
   AddStream(scope, pc, stream);
-  EXPECT_TRUE(GetTrack(pc, track_component));
+  EXPECT_TRUE(pc->GetTrack(track_component));
 
   RemoveStream(scope, pc, stream);
   // With a persistent |MediaStream|, the |MediaStreamTrack| and
   // |MediaStreamComponent| will not be destroyed and continue to be mapped by
   // peer connection.
   WebHeap::CollectAllGarbageForTesting();
-  EXPECT_TRUE(GetTrack(pc, track_component));
+  EXPECT_TRUE(pc->GetTrack(track_component));
 
   stream = nullptr;
   // Now |MediaStream|, |MediaStreamTrack| and |MediaStreamComponent| will be
   // destroyed and the mapping removed from the peer connection.
   WebHeap::CollectAllGarbageForTesting();
-  EXPECT_FALSE(GetTrack(pc, track_component));
+  EXPECT_FALSE(pc->GetTrack(track_component));
 }
 
 }  // namespace blink