Set audio format before adding pepper sink to audio track.

content/renderer/media/webrtc_local_audio_track.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/webrtc_local_audio_track.h"
 
 #include <limits>
 
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/renderer/media/media_stream_audio_level_calculator.h"
@@ skipping 22 matching lines @@
   DVLOG(1) << "WebRtcLocalAudioTrack::WebRtcLocalAudioTrack()";
 }
 
 WebRtcLocalAudioTrack::~WebRtcLocalAudioTrack() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::~WebRtcLocalAudioTrack()";
   // Users might not call Stop() on the track.
   Stop();
 }
 
+const media::AudioParameters& WebRtcLocalAudioTrack::GetOutputFormat() const {
+  if (webaudio_source_.get()) {
+    static const media::AudioParameters empty_params;

[dmichael (off chromium), 2015/01/20 17:07:03]

ditto...  it's almost always better to just return by-value. Is this object
really big or something? If there's an actual performance issue with returning
by value, a better alternative is an out-param (but even that is usually not
worthwhile for an object that just carries some fields).

[DaleCurtis, 2015/01/20 18:46:56]

+1, just return media::AudioParameters().

[Anand Mistry (off Chromium), 2015/01/27 02:12:10]

Done. I just figured returning const reference was good practice to avoid
unnecessary copies. Ya know, death by a thousand cuts, and all that.

[dmichael (off chromium), 2015/01/27 18:24:10]

Copying a small-ish object that doesn't do any heap allocations is pretty cheap.
In fact, the compiler can sometimes avoid the copy altogether. Function-local
statics, meanwhile, require the compiler to generate code that ensures they are
initialized on the first invocation of the function, so that might actually be
more expensive. Also, in Chromium, these function-local statics are not
thread-safe (they're not guaranteed thread safe by the language...  compilers
may make them thread-safe, but we turn that off). And...  this kind of
optimization is so small it's unlikely it would ever show up on any benchmark or
profiler (even if the static way is faster, which it may not be). We should aim
for code clarity in this kind of situation.

+    return empty_params;
+  } else {
+    return capturer_->GetOutputFormat();
+  }
+}
+
 void WebRtcLocalAudioTrack::Capture(const media::AudioBus& audio_bus,
                                     base::TimeTicks estimated_capture_time,
                                     bool force_report_nonzero_energy) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   DCHECK(!estimated_capture_time.is_null());
 
   // Calculate the signal level regardless of whether the track is disabled or
   // enabled.  If |force_report_nonzero_energy| is true, |audio_bus| contains
   // post-processed data that may be all zeros even though the signal contained
   // energy before the processing.  In this case, report nonzero energy even if
@@ skipping 168 matching lines @@
     (*it)->Reset();
   }
 }
 
 webrtc::AudioTrackInterface* WebRtcLocalAudioTrack::GetAudioAdapter() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return adapter_.get();
 }
 
 }  // namespace content