Fix more disabled MSVC warnings, base/ edition.

base/sync_socket_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 "base/sync_socket.h"
 
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/scoped_handle.h"
 
@@ skipping 133 matching lines @@
     // This is either the ReadFile or WriteFile call depending on whether
     // we're receiving or sending data.
     DWORD len = 0;
     const BOOL operation_ok = operation(
         file, static_cast<BufferType*>(buffer) + count, chunk, &len, &ol);
     if (!operation_ok) {
       if (::GetLastError() == ERROR_IO_PENDING) {
         HANDLE events[] = { io_event->handle(), cancel_event->handle() };
         const int wait_result = WaitForMultipleObjects(
             ARRAYSIZE_UNSAFE(events), events, FALSE,
-            timeout_in_ms == INFINITE
-                ? timeout_in_ms
-                : (finish_time - current_time).InMilliseconds());
+            timeout_in_ms == INFINITE ?
+                timeout_in_ms :
+                static_cast<DWORD>(
+                    (finish_time - current_time).InMilliseconds()));
         if (wait_result != WAIT_OBJECT_0 + 0) {
           // CancelIo() doesn't synchronously cancel outstanding IO, only marks
           // outstanding IO for cancellation. We must call GetOverlappedResult()
           // below to ensure in flight writes complete before returning.
           CancelIo(file);
         }
 
         // We set the |bWait| parameter to TRUE for GetOverlappedResult() to
         // ensure writes are complete before returning.
         if (!GetOverlappedResult(file, &ol, &len, TRUE))
@@ skipping 154 matching lines @@
   return CancelableFileOperation(
       &ReadFile, handle_, reinterpret_cast<char*>(buffer), length,
       &file_operation_, &shutdown_event_, this, INFINITE);
 }
 
 size_t CancelableSyncSocket::ReceiveWithTimeout(void* buffer,
                                                 size_t length,
                                                 TimeDelta timeout) {
   return CancelableFileOperation(
       &ReadFile, handle_, reinterpret_cast<char*>(buffer), length,
-      &file_operation_, &shutdown_event_, this, timeout.InMilliseconds());
+      &file_operation_, &shutdown_event_, this,
+      static_cast<DWORD>(timeout.InMilliseconds()));
 }
 
 // static
 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
                                       CancelableSyncSocket* socket_b) {
   return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, true);
 }
 
 }  // namespace base