Fixes for re-enabling more MSVC level 4 warnings: media/ edition

media/video/capture/win/video_capture_device_factory_win.cc

 // Copyright 2014 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_factory_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 
 #include "base/command_line.h"
@@ skipping 149 matching lines @@
 }
 
 static void GetDeviceNamesMediaFoundation(
     VideoCaptureDevice::Names* device_names) {
   DVLOG(1) << " GetDeviceNamesMediaFoundation";
   ScopedCoMem<IMFActivate*> devices;
   UINT32 count;
   if (!EnumerateVideoDevicesMediaFoundation(&devices, &count))
     return;
 
-  HRESULT hr;
   for (UINT32 i = 0; i < count; ++i) {
-    UINT32 name_size, id_size;
-    ScopedCoMem<wchar_t> name, id;
-    if (SUCCEEDED(hr = devices[i]->GetAllocatedString(
-            MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &name_size)) &&
-        SUCCEEDED(hr = devices[i]->GetAllocatedString(
-            MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
-            &id_size))) {
-      std::wstring name_w(name, name_size), id_w(id, id_size);
-      VideoCaptureDevice::Name device(base::SysWideToUTF8(name_w),
-          base::SysWideToUTF8(id_w),
-          VideoCaptureDevice::Name::MEDIA_FOUNDATION);
-      device_names->push_back(device);
-    } else {
+    ScopedCoMem<wchar_t> name;
+    UINT32 name_size;

[ddorwin, 2014/07/08 18:17:50]

nit: initialize? ditto for id_size.

[Peter Kasting, 2014/07/08 18:39:14]

I'm happy to do so if you like; there's no need to, since these are set
unconditionally in the function calls that immediately follow their declarations
(and the compiler is smart enough to figure that out).  Let me know and I'll
stick "= 0"s in.

+    HRESULT hr = devices[i]->GetAllocatedString(
+        MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &name_size);
+    if (SUCCEEDED(hr)) {
+      ScopedCoMem<wchar_t> id;
+      UINT32 id_size;
+      hr = devices[i]->GetAllocatedString(
+          MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
+          &id_size);
+      if (SUCCEEDED(hr)) {
+        device_names->push_back(VideoCaptureDevice::Name(
+            base::SysWideToUTF8(std::wstring(name, name_size)),
+            base::SysWideToUTF8(std::wstring(id, id_size)),
+            VideoCaptureDevice::Name::MEDIA_FOUNDATION));
+      }
+    }
+    if (FAILED(hr))
       DLOG(WARNING) << "GetAllocatedString failed: " << std::hex << hr;
-    }
     devices[i]->Release();
   }
 }
 
 static void GetDeviceSupportedFormatsDirectShow(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* formats) {
   DVLOG(1) << "GetDeviceSupportedFormatsDirectShow for " << device.name();
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
@@ skipping 82 matching lines @@
 static void GetDeviceSupportedFormatsMediaFoundation(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* formats) {
   DVLOG(1) << "GetDeviceSupportedFormatsMediaFoundation for " << device.name();
   ScopedComPtr<IMFMediaSource> source;
   if (!CreateVideoCaptureDeviceMediaFoundation(device.id().c_str(),
                                                source.Receive())) {
     return;
   }
 
-  HRESULT hr;
   base::win::ScopedComPtr<IMFSourceReader> reader;
-  if (FAILED(hr = MFCreateSourceReaderFromMediaSource(source, NULL,
-                                                      reader.Receive()))) {
+  HRESULT hr =
+      MFCreateSourceReaderFromMediaSource(source, NULL, reader.Receive());
+  if (FAILED(hr)) {
     DLOG(ERROR) << "MFCreateSourceReaderFromMediaSource: " << std::hex << hr;
     return;
   }
 
   DWORD stream_index = 0;
   ScopedComPtr<IMFMediaType> type;
-  while (SUCCEEDED(hr = reader->GetNativeMediaType(
-         MF_SOURCE_READER_FIRST_VIDEO_STREAM, stream_index, type.Receive()))) {
+  for (hr = reader->GetNativeMediaType(kFirstVideoStream, stream_index,
+                                       type.Receive());
+       SUCCEEDED(hr);
+       hr = reader->GetNativeMediaType(kFirstVideoStream, stream_index,
+                                       type.Receive())) {
     UINT32 width, height;
     hr = MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width, &height);
     if (FAILED(hr)) {
       DLOG(ERROR) << "MFGetAttributeSize: " << std::hex << hr;
       return;
     }
     VideoCaptureFormat capture_format;
     capture_format.frame_size.SetSize(width, height);
 
     UINT32 numerator, denominator;
@@ skipping 62 matching lines @@
     DCHECK(PlatformSupportsMediaFoundation());
     device.reset(new VideoCaptureDeviceMFWin(device_name));
     DVLOG(1) << " MediaFoundation Device: " << device_name.name();
     ScopedComPtr<IMFMediaSource> source;
     if (!CreateVideoCaptureDeviceMediaFoundation(device_name.id().c_str(),
                                                  source.Receive())) {
       return scoped_ptr<VideoCaptureDevice>();
     }
     if (!static_cast<VideoCaptureDeviceMFWin*>(device.get())->Init(source))
       device.reset();
-  } else if (device_name.capture_api_type() ==
-             VideoCaptureDevice::Name::DIRECT_SHOW) {
+  } else {
+    DCHECK_EQ(VideoCaptureDevice::Name::DIRECT_SHOW,

[ddorwin, 2014/07/08 18:17:50]

nit: media/ code prefers "var, const" for code except googletest macros.

[Peter Kasting, 2014/07/08 18:39:14]

Done.

+              device_name.capture_api_type());
     device.reset(new VideoCaptureDeviceWin(device_name));
     DVLOG(1) << " DirectShow Device: " << device_name.name();
     if (!static_cast<VideoCaptureDeviceWin*>(device.get())->Init())
       device.reset();
-  } else {
-    NOTREACHED() << " Couldn't recognize VideoCaptureDevice type";
   }
   return device.Pass();
 }
 
 void VideoCaptureDeviceFactoryWin::GetDeviceNames(
     VideoCaptureDevice::Names* device_names) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
     GetDeviceNamesMediaFoundation(device_names);
   else
     GetDeviceNamesDirectShow(device_names);
 }
 
 void VideoCaptureDeviceFactoryWin::GetDeviceSupportedFormats(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
     GetDeviceSupportedFormatsMediaFoundation(device, formats);
   else
     GetDeviceSupportedFormatsDirectShow(device, formats);
 }
 
 }  // namespace media