Reland CL to implement browser-side logging to WebRtc log.

content/browser/renderer_host/media/video_capture_device_impl.cc

 // Copyright 2013 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_device_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/callback_helpers.h"
@@ skipping 137 matching lines @@
     }
     capture_size_updated_ = true;
   }
 }
 
 void ThreadSafeCaptureOracle::Stop() {
   base::AutoLock guard(lock_);
   client_.reset();
 }
 
-void ThreadSafeCaptureOracle::ReportError() {
+void ThreadSafeCaptureOracle::ReportError(const std::string& reason) {
   base::AutoLock guard(lock_);
   if (client_)
-    client_->OnError();
+    client_->OnError(reason);
 }
 
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer,
     int frame_number,
     base::TimeTicks timestamp,
     bool success) {
   base::AutoLock guard(lock_);
   TRACE_EVENT_ASYNC_END2("mirroring", "Capture", buffer.get(),
                          "success", success,
@@ skipping 17 matching lines @@
     const media::VideoCaptureParams& params,
     scoped_ptr<media::VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ != kIdle) {
     DVLOG(1) << "Allocate() invoked when not in state Idle.";
     return;
   }
 
   if (params.requested_format.frame_rate <= 0) {
-    DVLOG(1) << "invalid frame_rate: " << params.requested_format.frame_rate;
-    client->OnError();
+    std::string error_msg = base::StringPrintf(
+        "invalid frame_rate: %d", params.requested_format.frame_rate);
+    DVLOG(1) << error_msg;
+    client->OnError(error_msg);
     return;
   }
 
   if (params.requested_format.frame_size.width() < kMinFrameWidth ||
       params.requested_format.frame_size.height() < kMinFrameHeight) {
-    DVLOG(1) << "invalid frame size: "
-             << params.requested_format.frame_size.ToString();
-    client->OnError();
+    std::string error_msg =
+        "invalid frame size: " + params.requested_format.frame_size.ToString();
+    DVLOG(1) << error_msg;
+    client->OnError(error_msg);
     return;
   }
 
   base::TimeDelta capture_period = base::TimeDelta::FromMicroseconds(
       1000000.0 / params.requested_format.frame_rate + 0.5);
 
   scoped_ptr<VideoCaptureOracle> oracle(
       new VideoCaptureOracle(capture_period,
                              kAcceleratedSubscriberIsSupported));
   oracle_proxy_ =
@@ skipping 26 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
           &VideoCaptureMachine::Stop,
           base::Unretained(capture_machine_.get()),
           base::Bind(&base::DoNothing)));
 }
 
 void VideoCaptureDeviceImpl::CaptureStarted(bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!success) {
-    DVLOG(1) << "Failed to start capture machine.";
-    Error();
+    std::string reason("Failed to start capture machine.");
+    DVLOG(1) << reason;
+    Error(reason);
   }
 }
 
 VideoCaptureDeviceImpl::VideoCaptureDeviceImpl(
     scoped_ptr<VideoCaptureMachine> capture_machine)
     : state_(kIdle),
       capture_machine_(capture_machine.Pass()) {}
 
 VideoCaptureDeviceImpl::~VideoCaptureDeviceImpl() {
   // If capture_machine is not NULL, then we need to return to the UI thread to
@@ skipping 17 matching lines @@
   static const char* kStateNames[] = {
     "Idle", "Allocated", "Capturing", "Error"
   };
   DVLOG(1) << "State change: " << kStateNames[state_]
            << " --> " << kStateNames[next_state];
 #endif
 
   state_ = next_state;
 }
 
-void VideoCaptureDeviceImpl::Error() {
+void VideoCaptureDeviceImpl::Error(const std::string& reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ == kIdle)
     return;
 
   if (oracle_proxy_)
-    oracle_proxy_->ReportError();
+    oracle_proxy_->ReportError(reason);
 
   StopAndDeAllocate();
   TransitionStateTo(kError);
 }
 
 }  // namespace content