Added initial set of logging for AudioOutputController.

content/browser/renderer_host/media/audio_output_delegate_impl.cc

 // Copyright 2016 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/browser/renderer_host/media/audio_output_delegate_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/media/audio_stream_monitor.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/media_internals.h"
 #include "content/browser/renderer_host/media/audio_sync_reader.h"
+#include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_observer.h"
 #include "media/audio/audio_output_controller.h"
 
 namespace content {
 
 // This class trampolines callbacks from the controller to the delegate. Since
 // callbacks from the controller are stopped asynchronously, this class holds
 // a weak pointer to the delegate, allowing the delegate to stop callbacks
 // synchronously.
 class AudioOutputDelegateImpl::ControllerEventHandler
     : public media::AudioOutputController::EventHandler {
  public:
   explicit ControllerEventHandler(
       base::WeakPtr<AudioOutputDelegateImpl> delegate);
 
  private:
   void OnControllerCreated() override;
   void OnControllerPlaying() override;
   void OnControllerPaused() override;
   void OnControllerError() override;
 
+  void OnLog(const std::string& message) override;
+
   base::WeakPtr<AudioOutputDelegateImpl> delegate_;
+  int stream_id_;  // Retained separately for logging.
 };
 
 AudioOutputDelegateImpl::ControllerEventHandler::ControllerEventHandler(
     base::WeakPtr<AudioOutputDelegateImpl> delegate)
-    : delegate_(std::move(delegate)) {}
+    : delegate_(std::move(delegate)), stream_id_(delegate_->stream_id_) {}
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerCreated() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&AudioOutputDelegateImpl::SendCreatedNotification,
                      delegate_));
 }
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerPlaying() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&AudioOutputDelegateImpl::UpdatePlayingState, delegate_,
                      true));
 }
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerPaused() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&AudioOutputDelegateImpl::UpdatePlayingState, delegate_,
                      false));
 }
 
 void AudioOutputDelegateImpl::ControllerEventHandler::OnControllerError() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&AudioOutputDelegateImpl::OnError, delegate_));
 }
 
+void AudioOutputDelegateImpl::ControllerEventHandler::OnLog(
+    const std::string& message) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&AudioOutputDelegateImpl::DoLog, stream_id_, message));

[Max Morin, 2017/05/29 14:25:44]

I just realized this should be BindOnce, like in all the other methods here.

[ossu-chromium, 2017/05/29 14:35:48]

I think I've been a bit hazy on the significance of Bind vs. BindOnce. I guess
that since each of these tasks will only be called once, BindOnce is the proper
one? Will fix!

[Max Morin, 2017/05/29 14:44:44]

Yes, it's a sort of documentation (with added efficiency bonus; since
OnceCallback is move-only, we don't have to reference count its internal state).
There are also some other neat things, like if you move something into the
BindOnce call, it will be moved out when the callback is called.

Basically, use BindOnce/OnceCallback when the callback should only be called
once, if that compiles.

+}
+
 std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
     EventHandler* handler,
     media::AudioManager* audio_manager,
     std::unique_ptr<media::AudioLog> audio_log,
     AudioMirroringManager* mirroring_manager,
     MediaObserver* media_observer,
     int stream_id,
     int render_frame_id,
     int render_process_id,
     const media::AudioParameters& params,
@@ skipping 132 matching lines @@
                                              render_frame_id_, stream_id_);
   }
 }
 
 void AudioOutputDelegateImpl::OnError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   audio_log_->OnError(stream_id_);
   subscriber_->OnStreamError(stream_id_);
 }
 

[liberato (no reviews please), 2017/05/30 16:53:34]

please add "// static".

[ossu-chromium, 2017/05/31 11:16:27]

See comment in audio_output_delegate_impl.h.

+void AudioOutputDelegateImpl::DoLog(int stream_id, const std::string& msg) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  std::ostringstream oss;
+  oss << "[stream_id=" << stream_id << "] " << msg;
+  const std::string message = oss.str();
+  content::MediaStreamManager::SendMessageToNativeLog(message);
+  DVLOG(1) << message;
+}
+
 media::AudioOutputController* AudioOutputDelegateImpl::GetControllerForTesting()
     const {
   return controller_.get();
 }
 
 }  // namespace content