Revert 48186, 48196, 48198

chrome_frame/test/exception_barrier_unittest.cc

 // Copyright (c) 2010 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 "gtest/gtest.h"
 #include "chrome_frame/exception_barrier.h"
 
 namespace {
 
 // retrieves the top SEH registration record
@@ skipping 11 matching lines @@
 //   # Is the registration DWORD aligned
 //   # Does each exception handler point to a module, as opposed to
 //      e.g. into the stack or never-never land.
 //   # Do successive entries in the exception chain increase
 //      monotonically in address
 void TestSEHChainSane() {
   // get the skinny on our stack segment
   MEMORY_BASIC_INFORMATION info = { 0 };
   // Note that we pass the address of the info struct just as a handy
   // moniker to anything at all inside our stack allocation
-  ASSERT_NE(0u, ::VirtualQuery(&info, &info, sizeof(info)));
+  ASSERT_NE(0, ::VirtualQuery(&info, &info, sizeof(info)));
 
   // The lower bound of our stack.
   // We use the address of info as a lower bound, this assumes that if this
   // function has an SEH handler, it'll be higher up in our invocation
   // record.
   EXCEPTION_REGISTRATION* limit =
           reinterpret_cast<EXCEPTION_REGISTRATION*>(&info);
   // the very top of our stack segment
   EXCEPTION_REGISTRATION* top =
           reinterpret_cast<EXCEPTION_REGISTRATION*>(
@@ skipping 10 matching lines @@
     // registrations must increase monotonically
     ASSERT_TRUE(curr > prev);
     // Check it's in bounds
     ASSERT_GE(top, curr);
     ASSERT_LT(limit, curr);
 
     // check for DWORD alignment
     ASSERT_EQ(0, (reinterpret_cast<UINT_PTR>(prev) & 0x00000003));
 
     // find the module hosting the handler
-    ASSERT_NE(0u, ::VirtualQuery(curr->handler, &info, sizeof(info)));
+    ASSERT_NE(0, ::VirtualQuery(curr->handler, &info, sizeof(info)));
     wchar_t module_filename[MAX_PATH];
-    ASSERT_NE(0u, ::GetModuleFileName(
+    ASSERT_NE(0, ::GetModuleFileName(
                     reinterpret_cast<HMODULE>(info.AllocationBase),
                     module_filename, ARRAYSIZE(module_filename)));
   }
 }
 
 void AccessViolationCrash() {
   volatile char* null = NULL;
   *null = '\0';
 }
 
@@ skipping 273 matching lines @@
   return TestRegularChaining(top) && TestExceptionBarrierChaining(top);
 }
 
 // Test that the SEH chain is unmolested by exception barrier, both under
 // regular unroll, and under exception unroll.
 TEST_F(ExceptionBarrierTest, SEHChainIsSaneAfterException) {
   EXPECT_TRUE(TestChaining());
 }
 
 }  // namespace