Remove |remote| and |readonly| members of MediaStreamTrack

content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc

 // Copyright 2014 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/webrtc/webrtc_media_stream_adapter.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 29 matching lines @@
   void TearDown() override {
     adapter_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   blink::WebMediaStream CreateBlinkMediaStream(bool audio, bool video) {
     blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
         audio ? static_cast<size_t>(1) : 0);
     if (audio) {
       blink::WebMediaStreamSource audio_source;
-      audio_source.initialize("audio",
-                              blink::WebMediaStreamSource::TypeAudio,
-                              "audio",
-                              false /* remote */);
+      audio_source.initialize("audio", blink::WebMediaStreamSource::TypeAudio,
+                              "audio");
       ProcessedLocalAudioSource* const source = new ProcessedLocalAudioSource(
           -1 /* consumer_render_frame_id is N/A for non-browser tests */,
           StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "Mock audio device",
                            "mock_audio_device_id",
                            media::AudioParameters::kAudioCDSampleRate,
                            media::CHANNEL_LAYOUT_STEREO,
                            media::AudioParameters::kAudioCDSampleRate / 50),
           MockConstraintFactory().CreateWebMediaConstraints(),
           base::Bind(&WebRtcMediaStreamAdapterTest::OnAudioSourceStarted),
           dependency_factory_.get());
       source->SetAllowInvalidRenderFrameIdForTesting(true);
       audio_source.setExtraData(source);  // Takes ownership.
       audio_track_vector[0].initialize(audio_source);
       EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(),
                   Initialize(_, _, -1));
       EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(),
                   SetAutomaticGainControl(true));
       EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(), Start());
       EXPECT_CALL(*mock_audio_device_factory_.mock_capturer_source(), Stop());
       CHECK(source->ConnectToTrack(audio_track_vector[0]));
     }
 
     blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
         video ? static_cast<size_t>(1) : 0);
     MediaStreamSource::SourceStoppedCallback dummy_callback;
     if (video) {
       blink::WebMediaStreamSource video_source;
-      video_source.initialize("video",
-                              blink::WebMediaStreamSource::TypeVideo,
-                              "video",
-                              false /* remote */);
+      video_source.initialize("video", blink::WebMediaStreamSource::TypeVideo,
+                              "video");
       MediaStreamVideoSource* native_source =
           new MockMediaStreamVideoSource(false);
       video_source.setExtraData(native_source);
       blink::WebMediaConstraints constraints;
       constraints.initialize();
       video_track_vector[0] = MediaStreamVideoTrack::CreateVideoTrack(
           native_source, constraints,
           MediaStreamVideoSource::ConstraintsCallback(), true);
     }
 
@@ skipping 41 matching lines @@
 }
 
 // Test that we don't crash if a MediaStream is created in Blink with an unknown
 // audio sources. This can happen if a MediaStream is created with
 // remote audio track.
 TEST_F(WebRtcMediaStreamAdapterTest,
        CreateWebRtcMediaStreamWithoutAudioSource) {
   // Create a blink MediaStream description.
   blink::WebMediaStreamSource audio_source;
   audio_source.initialize("audio source",
-                          blink::WebMediaStreamSource::TypeAudio,
-                          "something",
-                          false /* remote */);
+                          blink::WebMediaStreamSource::TypeAudio, "something");
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks(
       static_cast<size_t>(1));
   audio_tracks[0].initialize(audio_source.id(), audio_source);
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks(
       static_cast<size_t>(0));
 
   blink::WebMediaStream blink_stream;
   blink_stream.initialize("new stream", audio_tracks, video_tracks);
   blink_stream.setExtraData(new content::MediaStream());
@@ skipping 19 matching lines @@
   EXPECT_TRUE(webrtc_stream()->GetVideoTracks().empty());
 
   native_stream->AddTrack(audio_tracks[0]);
   EXPECT_EQ(1u, webrtc_stream()->GetAudioTracks().size());
 
   native_stream->AddTrack(video_tracks[0]);
   EXPECT_EQ(1u, webrtc_stream()->GetVideoTracks().size());
 }
 
 }  // namespace content