Cleaned up the WebRtcAudioCapturer a bit.

content/renderer/media/media_stream_dependency_factory.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/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 287 matching lines @@
   web_stream->videoTracks(video_tracks);
   for (size_t i = 0; i < video_tracks.size(); ++i) {
     const blink::WebMediaStreamSource& source = video_tracks[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
     // Check if the source has already been created. This happens when the same
     // source is used in multiple MediaStreams as a result of calling
     // getUserMedia.
     if (source_data->video_source())
-      continue;
+     continue;

[perkj_chrome, 2014/01/12 21:53:06]

indentation

[no longer working on chromium, 2014/01/13 16:59:59]

Done.

 
     const bool is_screencast =
         source_data->device_info().device.type == MEDIA_TAB_VIDEO_CAPTURE ||
         source_data->device_info().device.type == MEDIA_DESKTOP_VIDEO_CAPTURE;
     source_data->SetVideoSource(
         CreateLocalVideoSource(source_data->device_info().session_id,
                                is_screencast,
                                &native_video_constraints).get());
     source_observer->AddSource(source_data->video_source());
   }
@@ skipping 41 matching lines @@
           constraints.AddMandatory(kConstraintEffectMap[i].constraint,
               webrtc::MediaConstraintsInterface::kValueFalse, true);
           DVLOG(1) << "Disabling platform effect: "
                    << kConstraintEffectMap[i].constraint;
         }
       }
       device_info.device.input.effects = effects;
     }
 
     scoped_refptr<WebRtcAudioCapturer> capturer(
-        MaybeCreateAudioCapturer(render_view_id, device_info));
+        CreateAudioCapturer(render_view_id, device_info));
     if (!capturer.get()) {
       DLOG(WARNING) << "Failed to create the capturer for device "
                     << device_info.device.id;
       sources_created.Run(web_stream, false);
       // TODO(xians): Don't we need to check if source_observer is observing
       // something? If not, then it looks like we have a leak here.
       // OTOH, if it _is_ observing something, then the callback might
       // be called multiple times which is likely also a bug.
       return;
     }
@@ skipping 67 matching lines @@
 
   scoped_refptr<WebAudioCapturerSource> webaudio_source;
   if (!source_data) {
     if (source.requiresAudioConsumer()) {
       // We're adding a WebAudio MediaStream.
       // Create a specific capturer for each WebAudio consumer.
       webaudio_source = CreateWebAudioSource(&source, &track_constraints);
       source_data =
           static_cast<MediaStreamSourceExtraData*>(source.extraData());
     } else {
+      // TODO(xians): Check with perkj on if this comment is valid.

[perkj_chrome, 2014/01/12 21:53:06]

Yes. CreateNativeAudioMediaStreamTrack is called whenever a new track is created
from blink. It can be from a gum call or from cloning a track. 
The the track happen to be a remote track- there is no source object implemented
yet.

[no longer working on chromium, 2014/01/13 16:59:59]

Done with removing the TODO. Good to know, thanks.

       // TODO(perkj): Implement support for sources from
       // remote MediaStreams.
       NOTIMPLEMENTED();
       return NULL;
     }
   }
 
-  std::string track_id = base::UTF16ToUTF8(track.id());
-  scoped_refptr<WebRtcAudioCapturer> capturer;
-  if (GetWebRtcAudioDevice())
-    capturer = GetWebRtcAudioDevice()->GetDefaultCapturer();
-
   scoped_refptr<webrtc::AudioTrackInterface> audio_track(
-      CreateLocalAudioTrack(track_id,
-                            capturer,
+      CreateLocalAudioTrack(base::UTF16ToUTF8(track.id()),
+                            source_data->GetAudioCapturer(),
                             webaudio_source.get(),
                             source_data->local_audio_source(),
                             &track_constraints));
   AddNativeTrackToBlinkTrack(audio_track.get(), track, true);
 
   audio_track->set_enabled(track.isEnabled());
 
   // Pass the pointer of the source provider to the blink audio track.
   blink::WebMediaStreamTrack writable_track = track;
   writable_track.setSourceProvider(static_cast<WebRtcLocalAudioTrack*>(
@@ skipping 440 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 scoped_refptr<WebRtcAudioCapturer>
-MediaStreamDependencyFactory::MaybeCreateAudioCapturer(
+MediaStreamDependencyFactory::CreateAudioCapturer(
     int render_view_id,
     const StreamDeviceInfo& device_info) {
   // TODO(xians): Handle the cases when gUM is called without a proper render
   // view, for example, by an extension.
   DCHECK_GE(render_view_id, 0);
 
   scoped_refptr<WebRtcAudioCapturer> capturer =
-      GetWebRtcAudioDevice()->GetDefaultCapturer();
+      WebRtcAudioCapturer::CreateCapturer(render_view_id, device_info);
 
-  // If the default capturer does not exist or |render_view_id| == -1, create
-  // a new capturer.
-  bool is_new_capturer = false;
-  if (!capturer.get()) {
-    capturer = WebRtcAudioCapturer::CreateCapturer();
-    is_new_capturer = true;
-  }
-
-  if (!capturer->Initialize(
-          render_view_id,
-          static_cast<media::ChannelLayout>(
-              device_info.device.input.channel_layout),
-          device_info.device.input.sample_rate,
-          device_info.device.input.frames_per_buffer,
-          device_info.session_id,
-          device_info.device.id,
-          device_info.device.matched_output.sample_rate,
-          device_info.device.matched_output.frames_per_buffer,
-          device_info.device.input.effects)) {
-    return NULL;
-  }
-
-  // Add the capturer to the WebRtcAudioDeviceImpl if it is a new capturer.
-  if (is_new_capturer)
+  // Add the capturer to the WebRtcAudioDeviceImpl since it needs some hardware
+  // information from the capturer.
+  if (capturer)

[perkj_chrome, 2014/01/12 21:53:06]

Can capturer be null? 

[no longer working on chromium, 2014/01/13 16:59:59]

Yes, CreateCapturer will return a NULL if it fails to create and initialize the
capturer using the passing |render_view_id| and |device_info|.

     GetWebRtcAudioDevice()->AddAudioCapturer(capturer);

[perkj_chrome, 2014/01/12 21:53:06]

Rename method to SetAudioCapturer if there can be only one? 

[no longer working on chromium, 2014/01/13 16:59:59]

A couple of days ago I landed a workaround to fix a crash when there are
multiple input streams. That means we can actually support multiple capturers,
it is not recommended, but it works. so I don't stop the previous capturers when
a new capturer is created.
AddAudioCapturer() is correct from this sense.

 
   return capturer;
 }
 
 void MediaStreamDependencyFactory::AddNativeTrackToBlinkTrack(
     webrtc::MediaStreamTrackInterface* native_track,
     const blink::WebMediaStreamTrack& webkit_track,
     bool is_local_track) {
   DCHECK(!webkit_track.isNull() && !webkit_track.extraData());
   blink::WebMediaStreamTrack track = webkit_track;
@@ skipping 65 matching lines @@
   if (!aec_dump_file_stream) {
     VLOG(1) << "Could not open AEC dump file.";
     base::ClosePlatformFile(aec_dump_file);
   } else {
     // |pc_factory_| takes ownership of |aec_dump_file_stream|.
     pc_factory_->StartAecDump(aec_dump_file_stream);
   }
 }
 
 }  // namespace content