Use explicit WebString conversion methods in content/renderer/media (unittests)

content/renderer/media/rtc_peer_connection_handler_unittest.cc

 // Copyright (c) 2012 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/renderer/media/rtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 317 matching lines @@
     CHECK(audio_source->ConnectToTrack(audio_tracks[0]));
     blink::WebVector<blink::WebMediaStreamTrack> video_tracks(
         static_cast<size_t>(1));
     blink::WebMediaConstraints video_constraints;
     video_constraints.initialize();
     video_tracks[0] = MediaStreamVideoTrack::CreateVideoTrack(
         native_video_source, video_constraints,
         MediaStreamVideoSource::ConstraintsCallback(), true);
 
     blink::WebMediaStream local_stream;
-    local_stream.initialize(base::UTF8ToUTF16(stream_label), audio_tracks,
-                            video_tracks);
+    local_stream.initialize(blink::WebString::fromUTF8(stream_label),

[jrummell, 2017/01/19 20:17:03]

Most of the conversions of UTF8ToUTF16() became fromASCII(). This one is
different. Is that by design? (Also the 1 change in
mock_media_stream_registry.cc.)

[kinuko, 2017/01/20 02:22:35]

I wasn't sure if this method always takes ascii stream_label or not (while
others are just taking constants, so it was easy to guess).  Either should work
if it's ascii (fromASCII is slightly faster), while we need to use fromUTF8
otherwise.  (Since we're in the testing code we could also fallback to always
use fromUTF8 to simplify these, if you prefer)

+                            audio_tracks, video_tracks);
     local_stream.setExtraData(new MediaStream());
     return local_stream;
   }
 
   // Creates a remote MediaStream and adds it to the mocked native
   // peer connection.
   rtc::scoped_refptr<webrtc::MediaStreamInterface> AddRemoteMockMediaStream(
       const std::string& stream_label,
       const std::string& video_track_label,
       const std::string& audio_track_label) {
@@ skipping 653 matching lines @@
   EXPECT_EQ(-1, mock_client_->candidate_mlineindex());
   EXPECT_EQ("", mock_client_->candidate_sdp());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnAddAndOnRemoveStream) {
   std::string remote_stream_label("remote_stream");
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 
   testing::InSequence sequence;
-  EXPECT_CALL(*mock_tracker_.get(), TrackAddStream(
-      pc_handler_.get(),
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label)),
-      PeerConnectionTracker::SOURCE_REMOTE));
-  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label))));
+  EXPECT_CALL(
+      *mock_tracker_.get(),
+      TrackAddStream(
+          pc_handler_.get(),
+          testing::Property(&blink::WebMediaStream::id,
+                            blink::WebString::fromASCII(remote_stream_label)),
+          PeerConnectionTracker::SOURCE_REMOTE));
+  EXPECT_CALL(*mock_client_.get(),
+              didAddRemoteStream(testing::Property(
+                  &blink::WebMediaStream::id,
+                  blink::WebString::fromASCII(remote_stream_label))));
 
-  EXPECT_CALL(*mock_tracker_.get(), TrackRemoveStream(
-      pc_handler_.get(),
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label)),
-      PeerConnectionTracker::SOURCE_REMOTE));
-  EXPECT_CALL(*mock_client_.get(), didRemoveRemoteStream(
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label))));
+  EXPECT_CALL(
+      *mock_tracker_.get(),
+      TrackRemoveStream(
+          pc_handler_.get(),
+          testing::Property(&blink::WebMediaStream::id,
+                            blink::WebString::fromASCII(remote_stream_label)),
+          PeerConnectionTracker::SOURCE_REMOTE));
+  EXPECT_CALL(*mock_client_.get(),
+              didRemoveRemoteStream(testing::Property(
+                  &blink::WebMediaStream::id,
+                  blink::WebString::fromASCII(remote_stream_label))));
 
   pc_handler_->observer()->OnAddStream(remote_stream);
   base::RunLoop().RunUntilIdle();
   pc_handler_->observer()->OnRemoveStream(remote_stream);
   base::RunLoop().RunUntilIdle();
 }
 
 // This test that WebKit is notified about remote track state changes.
 TEST_F(RTCPeerConnectionHandlerTest, RemoteTrackState) {
   std::string remote_stream_label("remote_stream");
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 
   testing::InSequence sequence;
-  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label))));
+  EXPECT_CALL(*mock_client_.get(),
+              didAddRemoteStream(testing::Property(
+                  &blink::WebMediaStream::id,
+                  blink::WebString::fromASCII(remote_stream_label))));
   pc_handler_->observer()->OnAddStream(remote_stream);
   base::RunLoop().RunUntilIdle();
   const blink::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   webkit_stream.audioTracks(audio_tracks);
   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive,
             audio_tracks[0].source().getReadyState());
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
@@ skipping 13 matching lines @@
   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded,
             video_tracks[0].source().getReadyState());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddAudioTrackFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   base::RunLoop run_loop;
 
   // Grab the added media stream when it's been successfully added to the PC.
   blink::WebMediaStream webkit_stream;
-  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label))))
-      .WillOnce(
-          DoAll(SaveArg<0>(&webkit_stream),
-                ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
+  EXPECT_CALL(*mock_client_.get(),
+              didAddRemoteStream(testing::Property(
+                  &blink::WebMediaStream::id,
+                  blink::WebString::fromASCII(remote_stream_label))))
+      .WillOnce(DoAll(SaveArg<0>(&webkit_stream),
+                      ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
   pc_handler_->observer()->OnAddStream(remote_stream);
   run_loop.Run();
 
   {
     // Test in a small scope so that  |audio_tracks| don't hold on to destroyed
     // source later.
     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
@@ skipping 22 matching lines @@
   webkit_stream.audioTracks(modified_audio_tracks2);
   EXPECT_EQ(1u, modified_audio_tracks2.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddVideoTrackFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   base::RunLoop run_loop;
 
   // Grab the added media stream when it's been successfully added to the PC.
   blink::WebMediaStream webkit_stream;
-  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label))))
-      .WillOnce(
-          DoAll(SaveArg<0>(&webkit_stream),
-                ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
+  EXPECT_CALL(*mock_client_.get(),
+              didAddRemoteStream(testing::Property(
+                  &blink::WebMediaStream::id,
+                  blink::WebString::fromASCII(remote_stream_label))))
+      .WillOnce(DoAll(SaveArg<0>(&webkit_stream),
+                      ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
   pc_handler_->observer()->OnAddStream(remote_stream);
   run_loop.Run();
 
   {
     // Test in a small scope so that  |video_tracks| don't hold on to destroyed
     // source later.
     blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
@@ skipping 21 matching lines @@
   webkit_stream.videoTracks(modified_video_tracks2);
   EXPECT_EQ(1u, modified_video_tracks2.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddTracksFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   base::RunLoop run_loop;
 
   // Grab the added media stream when it's been successfully added to the PC.
   blink::WebMediaStream webkit_stream;
-  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
-      testing::Property(&blink::WebMediaStream::id,
-                        base::UTF8ToUTF16(remote_stream_label))))
-      .WillOnce(
-          DoAll(SaveArg<0>(&webkit_stream),
-                ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
+  EXPECT_CALL(*mock_client_.get(),
+              didAddRemoteStream(testing::Property(
+                  &blink::WebMediaStream::id,
+                  blink::WebString::fromASCII(remote_stream_label))))
+      .WillOnce(DoAll(SaveArg<0>(&webkit_stream),
+                      ExitMessageLoop(&message_loop_, run_loop.QuitClosure())));
 
   rtc::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
   pc_handler_->observer()->OnAddStream(remote_stream);
   run_loop.Run();
 
   {
     // Test in a small scope so that  |audio_tracks| don't hold on to destroyed
     // source later.
     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
@@ skipping 95 matching lines @@
                                     testing::Ref(tracks[0])));
 
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 
   StopAllTracks(local_stream);
 }
 
 }  // namespace content