Implement browser-side logging to WebRtc log

content/browser/renderer_host/media/video_capture_controller.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/video_capture_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 103 matching lines @@
                                        int length,
                                        base::TimeTicks timestamp,
                                        int rotation,
                                        const VideoCaptureFormat& frame_format)
       OVERRIDE;
   virtual void OnIncomingCapturedBuffer(const scoped_refptr<Buffer>& buffer,
                                         media::VideoFrame::Format format,
                                         const gfx::Size& dimensions,
                                         base::TimeTicks timestamp,
                                         int frame_rate) OVERRIDE;
-  virtual void OnError() OVERRIDE;
+  virtual void OnError(const std::string& reason) OVERRIDE;
 
  private:
   scoped_refptr<Buffer> DoReserveOutputBuffer(media::VideoFrame::Format format,
                                               const gfx::Size& dimensions);
 
   // The controller to which we post events.
   const base::WeakPtr<VideoCaptureController> controller_;
 
   // The pool of shared-memory buffers used for capturing.
   const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
@@ skipping 286 matching lines @@
       FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedI420BufferOnIOThread,
           controller_,
           buffer,
           dimensions,
           frame_rate,
           timestamp));
 }
 
-void VideoCaptureController::VideoCaptureDeviceClient::OnError() {
+void VideoCaptureController::VideoCaptureDeviceClient::OnError(
+    const std::string& reason) {
+  MediaStreamManager::AddLogMessage("Error on video capture: " + reason);

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

I think you should add an identifier - the session id in the call to
AddLogMessage. AddLogMessage can then find the request that contain devices with
that session id and only log to the render process that use the session id.

Note that a real device can be used in several tabs and thus have multiple
session ids. I am a bit lost of what VideoCaptureDeviceClient represents.

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

I'm not sure if it's worth doing this. Here's my reasoning: Look at how DVLOG is
used. There's nothing being done to disambiguate DVLOG messages between multiple
tabs/sessions, i.e. if there's an error for some camera X, it is logged to the
console without explaining which tab it came from. I don't think we need
anything more sophisticated than that for native logging.

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

Talked offline. I looked into this, and I don't think I can implement this
without making a lot of plumbing changes. Since I don't think we really need
this, I'm going to keep the CL as-is and fix in follow-up CL if need be.

   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
 scoped_refptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureController::VideoCaptureDeviceClient::DoReserveOutputBuffer(
     media::VideoFrame::Format format,
     const gfx::Size& dimensions) {
   // The capture pipeline expects I420 for now.
@@ skipping 128 matching lines @@
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return controller_clients_.size();
 }
 
 }  // namespace content