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 349 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 74 matching lines @@
       source_data =
           static_cast<MediaStreamSourceExtraData*>(source.extraData());
     } else {
       // 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()),

[perkj_chrome, 2014/01/14 12:53:55]

you can also do track.id().utf8() if you want.I am not sure what is the
preferred method to use.

[no longer working on chromium, 2014/01/14 14:10:56]

Good to know. id().utf8() looks cleaner to me.

+                            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();
-
-  // 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)
-    GetWebRtcAudioDevice()->AddAudioCapturer(capturer);
-
-  return capturer;
+  return WebRtcAudioCapturer::CreateCapturer(render_view_id, device_info,
+                                             GetWebRtcAudioDevice());
 }
 
 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;
 
   if (track.source().type() == blink::WebMediaStreamSource::TypeVideo) {
@@ skipping 63 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