Revert of Windows video capture: Remove duplicated code from GetDeviceSupportedFormats*

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 288 matching lines @@
     return false;
   }
 
   hr = graph_builder_->AddFilter(sink_filter_, NULL);
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to add the send filter to the graph: "
                 << logging::SystemErrorCodeToString(hr);
     return false;
   }
 
-  return CreateCapabilityMap(
-      output_capture_pin_, capture_filter_, &capabilities_);
+  return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   client_ = client.Pass();
@@ skipping 146 matching lines @@
   state_ = kIdle;
 }
 
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8* buffer,
                                           int length) {
   client_->OnIncomingCapturedData(
       buffer, length, capture_format_, 0, base::TimeTicks::Now());
 }
 
-bool VideoCaptureDeviceWin::CreateCapabilityMap(IPin* output_capture_pin,
-                                                IBaseFilter* capture_filter,
-                                                CapabilityList* capabilities) {
+bool VideoCaptureDeviceWin::CreateCapabilityMap() {
+  DCHECK(CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
-  HRESULT hr = output_capture_pin->QueryInterface(stream_config.Receive());
-  if (FAILED(hr) || !stream_config) {
+  HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
+  if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
                     "capture device: " << logging::SystemErrorCodeToString(hr);
     return false;
   }
 
   // Get interface used for getting the frame rate.
   ScopedComPtr<IAMVideoControl> video_control;
-  hr = capture_filter->QueryInterface(video_control.Receive());
-  DLOG_IF(WARNING, FAILED(hr) || !video_control)
-      << "IAMVideoControl Interface NOT SUPPORTED: "
-      << logging::SystemErrorCodeToString(hr);
+  hr = capture_filter_.QueryInterface(video_control.Receive());
+  DLOG_IF(WARNING, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED: "
+                               << logging::SystemErrorCodeToString(hr);
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to GetNumberOfCapabilities: "
                 << logging::SystemErrorCodeToString(hr);
     return false;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
   for (int stream_index = 0; stream_index < count; ++stream_index) {
     ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(
         stream_index, 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 || !media_type.get()) {
+    if (hr != S_OK) {
       DLOG(ERROR) << "Failed to GetStreamCaps: "
                   << logging::SystemErrorCodeToString(hr);
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureFormat format;
       format.pixel_format =
           TranslateMediaSubtypeToPixelFormat(media_type->subtype);
       if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
         continue;
 
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
-      if (!h) {
-        DLOG(ERROR) << "VIDEOINFOHEADER is NULL";
-        continue;
-      }
       format.frame_size.SetSize(h->bmiHeader.biWidth, h->bmiHeader.biHeight);
 
       // Try to get a better |time_per_frame| from IAMVideoControl. If not, use
       // the value from VIDEOINFOHEADER.
       REFERENCE_TIME time_per_frame = h->AvgTimePerFrame;
       if (video_control) {
         ScopedCoMem<LONGLONG> max_fps;
         LONG list_size = 0;
         const SIZE size = {format.frame_size.width(),
                            format.frame_size.height()};
         hr = video_control->GetFrameRateList(
-            output_capture_pin, stream_index, size, &list_size, &max_fps);
+            output_capture_pin_, stream_index, size, &list_size, &max_fps);
         // Can't assume the first value will return the max fps.
         // Sometimes |list_size| will be > 0, but max_fps will be NULL. Some
         // drivers may return an HRESULT of S_FALSE which SUCCEEDED() translates
         // into success, so explicitly check S_OK. See http://crbug.com/306237.
         if (hr == S_OK && list_size > 0 && max_fps) {
           time_per_frame = *std::min_element(max_fps.get(),
                                              max_fps.get() + list_size);
         }
       }
 
       format.frame_rate =
           (time_per_frame > 0)
               ? (kSecondsToReferenceTime / static_cast<float>(time_per_frame))
               : 0.0;
 
-      capabilities->emplace_back(stream_index, format);
+      capabilities_.emplace_back(stream_index, format);
     }
   }
 
-  return !capabilities->empty();
+  return !capabilities_.empty();
 }
 
 // Set the power line frequency removal in |capture_filter_| if available.
 void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter() {
   const int power_line_frequency = GetPowerLineFrequencyForLocation();
   if (power_line_frequency != kPowerLine50Hz &&
       power_line_frequency != kPowerLine60Hz) {
     return;
   }
   ScopedComPtr<IKsPropertySet> ks_propset;
@@ skipping 75 matching lines @@
     return E_FAIL;
   return S_OK;
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
   state_ = kError;
   client_->OnError(reason);
 }
 }  // namespace media