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

content/renderer/media/media_recorder_handler_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 130 matching lines @@
   // For generating test AudioBuses
   media::SineWaveAudioSource audio_source_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MediaRecorderHandlerTest);
 };
 
 // Checks that canSupportMimeType() works as expected, by sending supported
 // combinations and unsupported ones.
 TEST_F(MediaRecorderHandlerTest, CanSupportMimeType) {
-  const WebString unsupported_mime_type(base::UTF8ToUTF16("video/mpeg"));
+  const WebString unsupported_mime_type(WebString::fromASCII("video/mpeg"));
   EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
                    unsupported_mime_type, WebString()));
 
-  const WebString mime_type_video(base::UTF8ToUTF16("video/webm"));
+  const WebString mime_type_video(WebString::fromASCII("video/webm"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_video, WebString()));
-  const WebString mime_type_video_uppercase(base::UTF8ToUTF16("video/WEBM"));
+  const WebString mime_type_video_uppercase(WebString::fromASCII("video/WEBM"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_video_uppercase, WebString()));
-  const WebString example_good_codecs_1(base::UTF8ToUTF16("vp8"));
+  const WebString example_good_codecs_1(WebString::fromASCII("vp8"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_video, example_good_codecs_1));
-  const WebString example_good_codecs_2(base::UTF8ToUTF16("vp9,opus"));
+  const WebString example_good_codecs_2(WebString::fromASCII("vp9,opus"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_video, example_good_codecs_2));
-  const WebString example_good_codecs_3(base::UTF8ToUTF16("VP9,opus"));
+  const WebString example_good_codecs_3(WebString::fromASCII("VP9,opus"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_video, example_good_codecs_3));
-  const WebString example_good_codecs_4(base::UTF8ToUTF16("H264"));
+  const WebString example_good_codecs_4(WebString::fromASCII("H264"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_video, example_good_codecs_4));
 
-  const WebString example_unsupported_codecs_1(base::UTF8ToUTF16("daala"));
+  const WebString example_unsupported_codecs_1(WebString::fromASCII("daala"));
   EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
                    mime_type_video, example_unsupported_codecs_1));
 
-  const WebString mime_type_audio(base::UTF8ToUTF16("audio/webm"));
+  const WebString mime_type_audio(WebString::fromASCII("audio/webm"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_audio, WebString()));
-  const WebString example_good_codecs_5(base::UTF8ToUTF16("opus"));
+  const WebString example_good_codecs_5(WebString::fromASCII("opus"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_audio, example_good_codecs_5));
-  const WebString example_good_codecs_6(base::UTF8ToUTF16("OpUs"));
+  const WebString example_good_codecs_6(WebString::fromASCII("OpUs"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_audio, example_good_codecs_6));
 
-  const WebString example_unsupported_codecs_2(base::UTF8ToUTF16("vorbis"));
+  const WebString example_unsupported_codecs_2(WebString::fromASCII("vorbis"));
   EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
                    mime_type_audio, example_unsupported_codecs_2));
 }
 
 // Checks that the initialization-destruction sequence works fine.
 TEST_P(MediaRecorderHandlerTest, InitializeStartStop) {
   AddTracks();
-  const WebString mime_type(base::UTF8ToUTF16(GetParam().mime_type));
-  const WebString codecs(base::UTF8ToUTF16(GetParam().codecs));
+  const WebString mime_type(WebString::fromASCII(GetParam().mime_type));
+  const WebString codecs(WebString::fromASCII(GetParam().codecs));
   EXPECT_TRUE(media_recorder_handler_->initialize(this, registry_.test_stream(),
                                                   mime_type, codecs, 0, 0));
   EXPECT_FALSE(recording());
   EXPECT_FALSE(hasVideoRecorders());
   EXPECT_FALSE(hasAudioRecorders());
 
   EXPECT_TRUE(media_recorder_handler_->start(0));
   EXPECT_TRUE(recording());
 
   EXPECT_TRUE(hasVideoRecorders() || !GetParam().has_video);
@@ skipping 10 matching lines @@
 }
 
 // Sends 2 frames and expect them as WebM contained encoded data in writeData().
 TEST_P(MediaRecorderHandlerTest, EncodeVideoFrames) {
   // Video-only test.
   if (GetParam().has_audio)
     return;
 
   AddTracks();
 
-  const WebString mime_type(base::UTF8ToUTF16(GetParam().mime_type));
-  const WebString codecs(base::UTF8ToUTF16(GetParam().codecs));
+  const WebString mime_type(WebString::fromASCII(GetParam().mime_type));
+  const WebString codecs(WebString::fromASCII(GetParam().codecs));
   EXPECT_TRUE(media_recorder_handler_->initialize(this, registry_.test_stream(),
                                                   mime_type, codecs, 0, 0));
   EXPECT_TRUE(media_recorder_handler_->start(0));
 
   InSequence s;
   const scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::CreateBlackFrame(gfx::Size(160, 80));
 
   {
     const size_t kEncodedSizeThreshold = 16;
@@ skipping 40 matching lines @@
                         ValuesIn(kMediaRecorderTestParams));
 
 // Sends 2 frames and expect them as WebM contained encoded data in writeData().
 TEST_P(MediaRecorderHandlerTest, EncodeAudioFrames) {
   // Audio-only test.
   if (GetParam().has_video)
     return;
 
   AddTracks();
 
-  const WebString mime_type(base::UTF8ToUTF16("audio/webm"));
+  const WebString mime_type(WebString::fromASCII("audio/webm"));
   EXPECT_TRUE(media_recorder_handler_->initialize(
       this, registry_.test_stream(), mime_type, WebString(), 0, 0));
   EXPECT_TRUE(media_recorder_handler_->start(0));
 
   InSequence s;
   const std::unique_ptr<media::AudioBus> audio_bus1 = NextAudioBus();
   const std::unique_ptr<media::AudioBus> audio_bus2 = NextAudioBus();
 
   media::AudioParameters params(
       media::AudioParameters::AUDIO_PCM_LINEAR, media::CHANNEL_LAYOUT_STEREO,
@@ skipping 43 matching lines @@
 }
 
 // Starts up recording and forces a WebmMuxer's libwebm error.
 TEST_P(MediaRecorderHandlerTest, WebmMuxerErrorWhileEncoding) {
   // Video-only test: Audio would be very similar.
   if (GetParam().has_audio)
     return;
 
   AddTracks();
 
-  const WebString mime_type(base::UTF8ToUTF16(GetParam().mime_type));
-  const WebString codecs(base::UTF8ToUTF16(GetParam().codecs));
+  const WebString mime_type(WebString::fromASCII(GetParam().mime_type));
+  const WebString codecs(WebString::fromASCII(GetParam().codecs));
   EXPECT_TRUE(media_recorder_handler_->initialize(this, registry_.test_stream(),
                                                   mime_type, codecs, 0, 0));
   EXPECT_TRUE(media_recorder_handler_->start(0));
 
   InSequence s;
   const scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::CreateBlackFrame(gfx::Size(160, 80));
 
   {
     const size_t kEncodedSizeThreshold = 16;
@@ skipping 20 matching lines @@
     run_loop.Run();
   }
 
 
   // Expect a last call on destruction, with size 0 and |lastInSlice| true.
   EXPECT_CALL(*this, writeData(nullptr, 0, true, _)).Times(1);
   media_recorder_handler_.reset();
 }
 
 }  // namespace content