clang/win: Let some chromium_code targets build with -Wextra.

base/profiler/native_stack_sampler_win.cc

 // Copyright 2015 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 <objbase.h>
 #include <windows.h>
 #include <winternl.h>
 
 #include <cstdlib>
 #include <map>
@@ skipping 227 matching lines @@
 
  private:
   HANDLE thread_handle_;
   bool was_successful_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedSuspendThread);
 };
 
 ScopedSuspendThread::ScopedSuspendThread(HANDLE thread_handle)
     : thread_handle_(thread_handle),
-      was_successful_(::SuspendThread(thread_handle) != -1) {
-}
+      was_successful_(::SuspendThread(thread_handle) !=
+                      static_cast<DWORD>(-1)) {}
 
 ScopedSuspendThread::~ScopedSuspendThread() {
   if (!was_successful_)
     return;
 
   // Disable the priority boost that the thread would otherwise receive on
   // resume. We do this to avoid artificially altering the dynamics of the
   // executing application any more than we already are by suspending and
   // resuming the thread.
   //
   // Note that this can racily disable a priority boost that otherwise would
   // have been given to the thread, if the thread is waiting on other wait
   // conditions at the time of SuspendThread and those conditions are satisfied
   // before priority boost is reenabled. The measured length of this window is
   // ~100us, so this should occur fairly rarely.
   ScopedDisablePriorityBoost disable_priority_boost(thread_handle_);
-  bool resume_thread_succeeded = ::ResumeThread(thread_handle_) != -1;
+  bool resume_thread_succeeded =
+      ::ResumeThread(thread_handle_) != static_cast<DWORD>(-1);
   CHECK(resume_thread_succeeded) << "ResumeThread failed: " << GetLastError();
 }
 
 // Suspends the thread with |thread_handle|, copies its stack and resumes the
 // thread, then records the stack into |instruction_pointers| and associated
 // modules into |modules|.
 //
 // IMPORTANT NOTE: No allocations from the default heap may occur in the
 // ScopedSuspendThread scope, including indirectly via use of DCHECK/CHECK or
 // other logging statements. Otherwise this code can deadlock on heap locks in
@@ skipping 219 matching lines @@
   if (thread_handle) {
     return scoped_ptr<NativeStackSampler>(new NativeStackSamplerWin(
         win::ScopedHandle(thread_handle),
         test_delegate));
   }
 #endif
   return scoped_ptr<NativeStackSampler>();
 }
 
 }  // namespace base