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

media/video/capture/win/video_capture_device_mf_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_mf_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 
 #include "base/memory/ref_counted.h"
@@ skipping 53 matching lines @@
       capability->frame_rate_numerator / capability->frame_rate_denominator;
 
   return true;
 }
 
 HRESULT FillCapabilities(IMFSourceReader* source,
                          CapabilityList* capabilities) {
   DWORD stream_index = 0;
   ScopedComPtr<IMFMediaType> type;
   HRESULT hr;
-  while (SUCCEEDED(hr = source->GetNativeMediaType(
-      MF_SOURCE_READER_FIRST_VIDEO_STREAM, stream_index, type.Receive()))) {
+  for (hr = source->GetNativeMediaType(kFirstVideoStream, stream_index,
+                                       type.Receive());
+       SUCCEEDED(hr);
+       hr = source->GetNativeMediaType(kFirstVideoStream, stream_index,
+                                       type.Receive())) {
     VideoCaptureCapabilityWin capability(stream_index++);
     if (FillCapabilitiesFromType(type, &capability))
       capabilities->Add(capability);
     type.Release();
   }
 
   if (capabilities->empty() && (SUCCEEDED(hr) || hr == MF_E_NO_MORE_TYPES))
     hr = HRESULT_FROM_WIN32(ERROR_EMPTY);
 
   return (hr == MF_E_NO_MORE_TYPES) ? S_OK : hr;
@@ skipping 101 matching lines @@
 
   return false;
 }
 
 const std::string VideoCaptureDevice::Name::GetModel() const {
   const size_t vid_prefix_size = sizeof(kVidPrefix) - 1;
   const size_t pid_prefix_size = sizeof(kPidPrefix) - 1;
   const size_t vid_location = unique_id_.find(kVidPrefix);
   if (vid_location == std::string::npos ||
       vid_location + vid_prefix_size + kVidPidSize > unique_id_.size()) {
-    return "";
+    return std::string();
   }
   const size_t pid_location = unique_id_.find(kPidPrefix);
   if (pid_location == std::string::npos ||
       pid_location + pid_prefix_size + kVidPidSize > unique_id_.size()) {
-    return "";
+    return std::string();
   }
   std::string id_vendor =
       unique_id_.substr(vid_location + vid_prefix_size, kVidPidSize);
   std::string id_product =
       unique_id_.substr(pid_location + pid_prefix_size, kVidPidSize);
   return id_vendor + ":" + id_product;
 }
 
 VideoCaptureDeviceMFWin::VideoCaptureDeviceMFWin(const Name& device_name)
     : name_(device_name), capture_(0) {
@@ skipping 25 matching lines @@
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
 
   base::AutoLock lock(lock_);
 
   client_ = client.Pass();
   DCHECK_EQ(capture_, false);
 
   CapabilityList capabilities;
   HRESULT hr = S_OK;
-  if (!reader_ || FAILED(hr = FillCapabilities(reader_, &capabilities))) {
-    OnError(hr);
-    return;
+  if (reader_) {
+    hr = FillCapabilities(reader_, &capabilities);
+    if (SUCCEEDED(hr)) {
+      VideoCaptureCapabilityWin found_capability =
+          capabilities.GetBestMatchedFormat(
+              params.requested_format.frame_size.width(),
+              params.requested_format.frame_size.height(),
+              params.requested_format.frame_rate);
+
+      ScopedComPtr<IMFMediaType> type;
+      hr = reader_->GetNativeMediaType(
+          kFirstVideoStream, found_capability.stream_index, type.Receive());
+      if (SUCCEEDED(hr)) {
+        hr = reader_->SetCurrentMediaType(kFirstVideoStream, NULL, type);
+        if (SUCCEEDED(hr)) {
+          hr = reader_->ReadSample(kFirstVideoStream, 0, NULL, NULL, NULL,
+                                   NULL);
+          if (SUCCEEDED(hr)) {
+            capture_format_ = found_capability.supported_format;
+            capture_ = true;
+            return;
+          }
+        }
+      }
+    }
   }
 
-  VideoCaptureCapabilityWin found_capability =
-      capabilities.GetBestMatchedFormat(
-          params.requested_format.frame_size.width(),
-          params.requested_format.frame_size.height(),
-          params.requested_format.frame_rate);
-
-  ScopedComPtr<IMFMediaType> type;
-  if (FAILED(hr = reader_->GetNativeMediaType(
-          MF_SOURCE_READER_FIRST_VIDEO_STREAM, found_capability.stream_index,
-          type.Receive())) ||
-      FAILED(hr = reader_->SetCurrentMediaType(
-          MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, type))) {
-    OnError(hr);
-    return;
-  }
-
-  if (FAILED(hr = reader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
-                                      NULL, NULL, NULL, NULL))) {
-    OnError(hr);
-    return;
-  }
-  capture_format_ = found_capability.supported_format;
-  capture_ = true;
+  OnError(hr);
 }
 
 void VideoCaptureDeviceMFWin::StopAndDeAllocate() {
   DCHECK(CalledOnValidThread());
   base::WaitableEvent flushed(false, false);
   const int kFlushTimeOutInMs = 1000;
   bool wait = false;
   {
     base::AutoLock lock(lock_);
     if (capture_) {
       capture_ = false;
       callback_->SetSignalOnFlush(&flushed);
-      HRESULT hr = reader_->Flush(MF_SOURCE_READER_ALL_STREAMS);
-      wait = SUCCEEDED(hr);
+      wait = SUCCEEDED(reader_->Flush(
+          static_cast<DWORD>(MF_SOURCE_READER_ALL_STREAMS)));
       if (!wait) {
         callback_->SetSignalOnFlush(NULL);
       }
     }
     client_.reset();
   }
 
   // If the device has been unplugged, the Flush() won't trigger the event
   // and a timeout will happen.
   // TODO(tommi): Hook up the IMFMediaEventGenerator notifications API and
   // do not wait at all after getting MEVideoCaptureDeviceRemoved event.
   // See issue/226396.
   if (wait)
     flushed.TimedWait(base::TimeDelta::FromMilliseconds(kFlushTimeOutInMs));
 }
 
 void VideoCaptureDeviceMFWin::OnIncomingCapturedData(
     const uint8* data,
     int length,
     int rotation,
     const base::TimeTicks& time_stamp) {
   base::AutoLock lock(lock_);
   if (data && client_.get()) {
     client_->OnIncomingCapturedData(
         data, length, capture_format_, rotation, time_stamp);
   }
 
   if (capture_) {
-    HRESULT hr = reader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
-                                     NULL, NULL, NULL, NULL);
+    HRESULT hr =
+        reader_->ReadSample(kFirstVideoStream, 0, NULL, NULL, NULL, NULL);
     if (FAILED(hr)) {
       // If running the *VideoCap* unit tests on repeat, this can sometimes
       // fail with HRESULT_FROM_WINHRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION).
       // It's not clear to me why this is, but it is possible that it has
       // something to do with this bug:
       // http://support.microsoft.com/kb/979567
       OnError(hr);
     }
   }
 }
 
 void VideoCaptureDeviceMFWin::OnError(HRESULT hr) {
   std::string log_msg = base::StringPrintf("VideoCaptureDeviceMFWin: %x", hr);
   DLOG(ERROR) << log_msg;
   if (client_.get())
     client_->OnError(log_msg);
 }
 
 }  // namespace media