Implement browser-side logging to WebRtc log

content/browser/renderer_host/media/media_stream_manager.h

 // 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.
 
 // MediaStreamManager is used to open/enumerate media capture devices (video
 // supported now). Call flow:
 // 1. GenerateStream is called when a render process wants to use a capture
 //    device.
 // 2. MediaStreamManager will ask MediaStreamUIController for permission to
 //    use devices and for which device to use.
@@ skipping 49 matching lines @@
 class CONTENT_EXPORT MediaStreamManager
     : public MediaStreamProviderListener,
       public base::MessageLoop::DestructionObserver,
       public base::SystemMonitor::DevicesChangedObserver {
  public:
   // Callback to deliver the result of a media request.
   typedef base::Callback<void(const MediaStreamDevices& devices,
                               scoped_ptr<MediaStreamUIProxy> ui)>
       MediaRequestResponseCallback;
 
+  // Callback to log a message to native logs.
+  typedef base::Callback<void(const std::string& message)>
+      AddWebRtcLogCallback;
+
   explicit MediaStreamManager(media::AudioManager* audio_manager);
   virtual ~MediaStreamManager();
 
   // Used to access VideoCaptureManager.
   VideoCaptureManager* video_capture_manager();
 
   // Used to access AudioInputDeviceManager.
   AudioInputDeviceManager* audio_input_device_manager();
 
   // Creates a new media access request which is identified by a unique string
@@ skipping 98 matching lines @@
   // This object gets deleted on the UI thread after the IO thread has been
   // destroyed. So we need to know when IO thread is being destroyed so that
   // we can delete VideoCaptureManager and AudioInputDeviceManager. Normally
   // this is handled by
   // base::MessageLoop::DestructionObserver::WillDestroyCurrentMessageLoop.
   // But for some tests which use TestBrowserThreadBundle, we need to call
   // WillDestroyCurrentMessageLoop explicitly because the notification happens
   // too late. (see http://crbug.com/247525#c14).
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 
+  // Adds |message| to native logs for outstanding device requests.

[Henrik Grunell, 2014/01/17 08:51:25]

Is sending the log to all outstanding requests' renderers what one would usually
want? I'm not particularly familiar with the MediaStream code in the browser
side, but it seems to me that we should log for the specific request this
message belongs to (if there is one, which I suppose there almost always is)?
Won't we spam logs with irrelevant information from other renderers this way?

[vrk (LEFT CHROMIUM), 2014/01/22 02:25:42]

See implementation of AddLogMessageOnUIThread(). This code should send all
outstanding requests to each respective RenderProcessHost, which will send it to
the respective WebRtcLogHandlerHost. 

So for example: 
render process id 1 has native logging started, calls getUserMedia
render process id 2 does not have native logging started, callsGetUserMedia

render process id 1 will send a log message to RenderProcessHost 1, which
forwards it to WebRtcLogHandlerHost, which will add the log because it has
started.
render process id 2 will send a log message to RenderProcessHost 2, which
forwards it to WebRtcLogHandlerHost, which will ignore the log message because
native logging never began.

Do you agree? Let me know if you still see an issue.

[Henrik Grunell, 2014/01/22 07:05:22]

Let's discuss offline.

+  void AddLogMessageOnUIThread(const std::string& message);
+  static void AddLogMessage(const std::string& message);
+
  protected:
   // Used for testing.
   MediaStreamManager();
 
  private:
   // Contains all data needed to keep track of requests.
   class DeviceRequest;
 
   // Cache enumerated device list.
   struct EnumerationCache {
@@ skipping 80 matching lines @@
                               DeviceRequest* request);
   void FinalizeRequestFailed(const std::string& label,
                              DeviceRequest* request);
   void FinalizeOpenDevice(const std::string& label,
                           DeviceRequest* request);
   void FinalizeMediaAccessRequest(const std::string& label,
                                   DeviceRequest* request,
                                   const MediaStreamDevices& devices);
   void FinalizeEnumerateDevices(const std::string& label,
                                 DeviceRequest* request);
+  void DoAddLogMessage(const std::string& message);

[Henrik Grunell, 2014/01/17 08:51:25]

Remove. Not implemented as a member function.

[vrk (LEFT CHROMIUM), 2014/01/22 02:25:42]

Thanks, done.

 
   // This method is called when an audio or video device is plugged in or
   // removed. It make sure all MediaStreams that use a removed device is
   // stopped and that the render process is notified. |old_devices| is the list
   // of previously available devices. |new_devices| is the new
   // list of currently available devices.
   void StopRemovedDevices(const StreamDeviceInfoArray& old_devices,
                           const StreamDeviceInfoArray& new_devices);
   // Helper method used by StopRemovedDevices to stop the use of a certain
   // device.
@@ skipping 50 matching lines @@
 
   bool use_fake_ui_;
   scoped_ptr<FakeMediaStreamUIProxy> fake_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_