Implement browser-side logging to WebRtc log

content/browser/renderer_host/media/media_stream_manager.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/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
+#include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/device_request_message_filter.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/browser/renderer_host/media/web_contents_capture_util.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/media_request_state.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
+static void DoAddLogMessage(const std::string& message) {
+  // Must be on the UI thread to access BrowserMainLoop.
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  content::BrowserMainLoop::GetInstance()->media_stream_manager()->
+      AddLogMessageOnUIThread(message);
+}
+
 namespace content {
 
 namespace {
 // Creates a random label used to identify requests.
 std::string RandomLabel() {
   // An earlier PeerConnection spec,
   // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the
   // MediaStream::label alphabet as containing 36 characters from
   // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E,
   // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E.
@@ skipping 1336 matching lines @@
 }
 
 void MediaStreamManager::Closed(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 void MediaStreamManager::DevicesEnumerated(
     MediaStreamType stream_type, const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DVLOG(1) << "DevicesEnumerated("
-           << ", {stream_type = " << stream_type <<  "})";
+  std::stringstream devices_msg;

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

I think someone told me in a CL not to use stringstream, but I can't find that
or anything in the style/code guides. So OK for me unless anyone else knows
more.

[perkj_chrome, 2014/01/22 10:03:29]

Streams are only allowed for logging:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Streams
Maybe this is not really what the style guide means though. 

[vrk (LEFT CHROMIUM), 2014/01/23 21:46:32]

Going to keep as-is. Let's fix this in a follow-up CL if need be.

+  devices_msg << "DevicesEnumerated("
+              << "{stream_type = " << stream_type << "})" << std::endl;
+  for (StreamDeviceInfoArray::const_iterator it = devices.begin();
+       it != devices.end(); ++it) {
+    devices_msg << "  " << it->device.name << " ("
+                << it->device.id << ")" << std::endl;
+  }
+  if (devices.empty())
+    devices_msg << "No devices found.";
+
+  DVLOG(1) << devices_msg;
+  AddLogMessage(devices_msg.str());
 
   // Only cache the device list when the device list has been changed.
   bool need_update_clients = false;
   EnumerationCache* cache =
       stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ?
       &audio_enumeration_cache_ : &video_enumeration_cache_;
   if (!cache->valid ||
       devices.size() != cache->devices.size() ||
       !std::equal(devices.begin(), devices.end(), cache->devices.begin(),
                   StreamDeviceInfo::IsEqual)) {
@@ skipping 52 matching lines @@
         else
           PostRequestToUI(*it, request);
         break;
     }
   }
   label_list.clear();
   --active_enumeration_ref_count_[stream_type];
   DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
 }
 
+// static
+void MediaStreamManager::AddLogMessage(const std::string& message) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(::DoAddLogMessage, message));
+}
+
+void MediaStreamManager::AddLogMessageOnUIThread(const std::string& message) {
+  // Must be on the UI thread to access RenderProcessHost from process ID.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // Add logs for each pending request.
+  for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end();

[perkj_chrome, 2014/01/22 10:03:29]

Are you aware that a request is "Pending" as long as the request has devices
opened? Ie- it only goes out of scope when the last device in the request has
been stopped.
(MediaStreamTrack::Stop() or MediaSTream::Stop()) or the page has been reloaded
etc..
Ie- if you do GetUserMedia twice - you will have two active requests and thus it
looks like you will send the same message twice to the same render process. 

Also- this will send the log to all render processes that have a MediaStream
running. Regardless if the tab has anything to do with the error.

[vrk (LEFT CHROMIUM), 2014/01/22 18:30:30]

I think this behavior is acceptable in practice. We're really looking to add
logging to debug problems in the common and easy use case, which is one app in
one tab using WebRTC. Do you agree? If not, can you explain the scenario you're
concerned about, and the behavior you'd prefer?

[vrk (LEFT CHROMIUM), 2014/01/23 21:46:32]

Talked offline. This is hard to fix and I think the behavior should be good
enough for now, so going to leave as-is and fix in follow-up CL if need be.

+       ++it) {
+    DeviceRequest* request = it->second;
+    // Log the message to all renderers that are requesting a MediaStream or
+    // device enumeration.

[perkj_chrome, 2014/01/22 10:03:29]

Can you add this comment to the header file as well?

[vrk (LEFT CHROMIUM), 2014/01/23 21:46:32]

Done, though reworded.

+    if (request->request_type == MEDIA_GENERATE_STREAM ||
+        request->request_type == MEDIA_ENUMERATE_DEVICES) {
+      content::RenderProcessHostImpl* render_process_host_impl =
+          static_cast<content::RenderProcessHostImpl*>(
+              content::RenderProcessHost::FromID(
+                  request->requesting_process_id));
+      render_process_host_impl->WebRtcLogMessage(message);
+    }
+  }
+}
+
 void MediaStreamManager::HandleAccessRequestResponse(
     const std::string& label,
     const MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "HandleAccessRequestResponse("
            << ", {label = " << label <<  "})";
 
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     // The request has been canceled before the UI returned.
@@ skipping 215 matching lines @@
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices(stream_type);
 }
 
 }  // namespace content