Log error messages in windows video capture

media/video/capture/win/video_capture_device_win.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 "media/video/capture/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
@@ skipping 50 matching lines @@
     for (size_t i = 0;
          i < arraysize(kPropertyNames) && name.type() != VT_BSTR; ++i) {
       prop_bag->Read(kPropertyNames[i], name.Receive(), 0);
     }
     if (name.type() == VT_BSTR) {
       std::string device_path(base::SysWideToUTF8(V_BSTR(&name)));
       if (device_path.compare(device_name.id()) == 0) {
         // We have found the requested device
         hr = moniker->BindToObject(0, 0, IID_IBaseFilter,
                                    capture_filter.ReceiveVoid());
-        DVPLOG_IF(2, FAILED(hr)) << "Failed to bind camera filter.";
+        DPLOG_IF(ERROR, FAILED(hr)) << "Failed to bind camera filter";
         break;
       }
     }
     moniker.Release();
   }
 
   *filter = capture_filter.Detach();
   if (!*filter && SUCCEEDED(hr))
     hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 
@@ skipping 135 matching lines @@
 
     if (mjpg_filter_)
       graph_builder_->RemoveFilter(mjpg_filter_);
   }
 }
 
 bool VideoCaptureDeviceWin::Init() {
   DCHECK(CalledOnValidThread());
   HRESULT hr = GetDeviceFilter(device_name_, capture_filter_.Receive());
   if (!capture_filter_) {
-    DVLOG(2) << "Failed to create capture filter.";
+    DPLOG(ERROR) << "Failed to create capture filter";
     return false;
   }
 
   output_capture_pin_ =
       GetPin(capture_filter_, PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE);
   if (!output_capture_pin_) {
-    DVLOG(2) << "Failed to get capture output pin";
+    DPLOG(ERROR) << "Failed to get capture output pin";
     return false;
   }
 
   // Create the sink filter used for receiving Captured frames.
   sink_filter_ = new SinkFilter(this);
   if (sink_filter_ == NULL) {
-    DVLOG(2) << "Failed to create send filter";
+    DPLOG(ERROR) << "Failed to create send filter";
     return false;
   }
 
   input_sink_pin_ = sink_filter_->GetPin(0);
 
   hr = graph_builder_.CreateInstance(CLSID_FilterGraph, NULL,
                                      CLSCTX_INPROC_SERVER);
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to create graph builder.";
+    DPLOG(ERROR) << "Failed to create graph builder";
     return false;
   }
 
   hr = graph_builder_.QueryInterface(media_control_.Receive());
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to create media control builder.";
+    DPLOG(ERROR) << "Failed to create media control builder";
     return false;
   }
 
   hr = graph_builder_->AddFilter(capture_filter_, NULL);
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to add the capture device to the graph.";
+    DPLOG(ERROR) << "Failed to add the capture device to the graph";
     return false;
   }
 
   hr = graph_builder_->AddFilter(sink_filter_, NULL);
   if (FAILED(hr)) {
-    DVLOG(2)<< "Failed to add the send filter to the graph.";
+    DPLOG(ERROR)<< "Failed to add the send filter to the graph";
     return false;
   }
 
   return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
@@ skipping 152 matching lines @@
                                           int length) {
   client_->OnIncomingCapturedData(
       buffer, length, capture_format_, 0, base::TimeTicks::Now());
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
   DCHECK(CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to get IAMStreamConfig interface from "
-                "capture device";
+    DPLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
+                    "capture device";
     return false;
   }
 
   // Get interface used for getting the frame rate.
   ScopedComPtr<IAMVideoControl> video_control;
   hr = capture_filter_.QueryInterface(video_control.Receive());
-  DVLOG_IF(2, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED";
+  DPLOG_IF(ERROR, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED";
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
-    DVLOG(2) << "Failed to GetNumberOfCapabilities";
+    DPLOG(ERROR) << "Failed to GetNumberOfCapabilities";
     return false;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
   for (int i = 0; i < count; ++i) {
     ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
     // GetStreamCaps() may return S_FALSE, so don't use FAILED() or SUCCEED()
     // macros here since they'll trigger incorrectly.
     if (hr != S_OK) {
-      DVLOG(2) << "Failed to GetStreamCaps";
+      DPLOG(ERROR) << "Failed to GetStreamCaps";
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureCapabilityWin capability(i);
       capability.supported_format.pixel_format =
           TranslateMediaSubtypeToPixelFormat(media_type->subtype);
       if (capability.supported_format.pixel_format == PIXEL_FORMAT_UNKNOWN)
         continue;
@@ skipping 61 matching lines @@
       (type_support & KSPROPERTY_SUPPORT_SET)) {
     KSPROPERTY_VIDEOPROCAMP_S data = {};
     data.Property.Set = PROPSETID_VIDCAP_VIDEOPROCAMP;
     data.Property.Id = KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY;
     data.Property.Flags = KSPROPERTY_TYPE_SET;
     data.Value = (power_line_frequency == kPowerLine50Hz) ? 1 : 2;
     data.Flags = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
     hr = ks_propset->Set(PROPSETID_VIDCAP_VIDEOPROCAMP,
                          KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY,
                          &data, sizeof(data), &data, sizeof(data));
-    DVLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed.";
+    DPLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed";
     DVLOG_IF(2, SUCCEEDED(hr)) << "Anti-flicker set correctly.";
   } else {
     DVLOG(2) << "Anti-flicker setting not supported.";
   }
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << reason;
+  const std::string last_err_msg =
+      logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode());
+  const std::string log_msg = base::StringPrintf("%s, OS message: %s",
+                                                 reason.c_str(),
+                                                 last_err_msg.c_str());
+  DLOG(ERROR) << log_msg;
   state_ = kError;
-  client_->OnError(reason);
+  client_->OnError(log_msg);

[perkj_chrome, 2014/08/27 10:45:48]

mcasas - you suggested we should move the above lines to os independendent
layer. 

so should we move the line
logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode()); to
VideoCaptureController::VideoCaptureDeviceClient::OnError ?

[mcasas, 2014/08/27 11:34:09]

Fine by me, just make sure we log both via screen dump and
webrtc log.

 }
 }  // namespace media