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(

[Max Morin, 2017/05/31 13:51:59]

Remove explicit since it has two parameters now.

-      base::WeakPtr<AudioOutputDelegateImpl> delegate);
+      base::WeakPtr<AudioOutputDelegateImpl> delegate,
+      int stream_id);
 
  private:
   void OnControllerCreated() override;
   void OnControllerPlaying() override;
   void OnControllerPaused() override;
   void OnControllerError() override;
+  void OnLog(const std::string& message) override;
 
   base::WeakPtr<AudioOutputDelegateImpl> delegate_;
+  const int stream_id_;  // Retained separately for logging.
 };
 
 AudioOutputDelegateImpl::ControllerEventHandler::ControllerEventHandler(
-    base::WeakPtr<AudioOutputDelegateImpl> delegate)
-    : delegate_(std::move(delegate)) {}
+    base::WeakPtr<AudioOutputDelegateImpl> delegate,
+    int stream_id)
+    : delegate_(std::move(delegate)), stream_id_(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) {
+  std::ostringstream oss;
+  oss << "[stream_id=" << stream_id_ << "] " << message;
+  const std::string out_message = oss.str();
+  content::MediaStreamManager::SendMessageToNativeLog(out_message);
+  DVLOG(1) << out_message;
+}
+
 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 30 matching lines @@
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(subscriber_);
   DCHECK(audio_manager);
   DCHECK(audio_log_);
   DCHECK(mirroring_manager_);
   DCHECK(reader_);
   // Since the event handler never directly calls functions on |this| but rather
   // posts them to the IO thread, passing a pointer from the constructor is
   // safe.
-  controller_event_handler_ =
-      base::MakeUnique<ControllerEventHandler>(weak_factory_.GetWeakPtr());
+  controller_event_handler_ = base::MakeUnique<ControllerEventHandler>(
+      weak_factory_.GetWeakPtr(), stream_id_);
   audio_log_->OnCreated(stream_id, params, output_device_id);
   controller_ = media::AudioOutputController::Create(
       audio_manager, controller_event_handler_.get(), params, output_device_id,
       reader_.get());
   DCHECK(controller_);
   if (media_observer)
     media_observer->OnCreatingAudioStream(render_process_id, render_frame_id);
   mirroring_manager_->AddDiverter(render_process_id, render_frame_id,
                                   controller_.get());
 }
@@ skipping 87 matching lines @@
   audio_log_->OnError(stream_id_);
   subscriber_->OnStreamError(stream_id_);
 }
 
 media::AudioOutputController* AudioOutputDelegateImpl::GetControllerForTesting()
     const {
   return controller_.get();
 }
 
 }  // namespace content