Unsigned warning fix - take 2

chrome_frame/function_stub_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 "chrome_frame/function_stub.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace {
@@ skipping 56 matching lines @@
   typedef uintptr_t (CALLBACK *FuncPtr1)(uintptr_t arg);
 
   MOCK_METHOD0(Foo0, uintptr_t());
   MOCK_METHOD1(Foo1, uintptr_t(uintptr_t));
   MOCK_METHOD0(Bar0, uintptr_t());
   MOCK_METHOD1(Bar1, uintptr_t(uintptr_t));
 
   static uintptr_t CALLBACK FooCallback0(FunctionStubTest* test) {
     return test->Foo0();
   }
-  static uintptr_t CALLBACK FooCallback1(FunctionStubTest* test, uintptr_t arg) {
+  static uintptr_t CALLBACK FooCallback1(FunctionStubTest* test,
+                                         uintptr_t arg) {
     return test->Foo1(arg);
   }
   static uintptr_t CALLBACK BarCallback0(FunctionStubTest* test) {
     return test->Foo0();
   }
-  static uintptr_t CALLBACK BarCallback1(FunctionStubTest* test, uintptr_t arg) {
+  static uintptr_t CALLBACK BarCallback1(FunctionStubTest* test,
+                                         uintptr_t arg) {
     return test->Foo1(arg);
   }
 
   // If a stub is allocated during testing, assigning it here
   // will deallocate it at the end of test.
   FunctionStub* stub_;
 
   // playpen_[0 .. playpen_size_ - 1] is committed, writable memory.
   // playpen_[playpen_size_] is uncommitted, defined memory.
   uint8* playpen_;
@@ skipping 18 matching lines @@
   uintptr_t argument = reinterpret_cast<uintptr_t>(this);
   uintptr_t dest_fn = reinterpret_cast<uintptr_t>(FooDivert);
   stub_ = FunctionStub::Create(argument, FooDivert);
 
   EXPECT_FALSE(stub_->is_bypassed());
   EXPECT_TRUE(stub_->is_valid());
   EXPECT_TRUE(stub_->code() != NULL);
 
   // Check that the stub code is executable.
   MEMORY_BASIC_INFORMATION info = {};
-  EXPECT_NE(0, ::VirtualQuery(stub_->code(), &info, sizeof(info)));
+  EXPECT_NE(0u, ::VirtualQuery(stub_->code(), &info, sizeof(info)));
   const DWORD kExecutableMask = PAGE_EXECUTE | PAGE_EXECUTE_READ |
       PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;
-  EXPECT_NE(0, info.Protect & kExecutableMask);
+  EXPECT_NE(0u, info.Protect & kExecutableMask);
 
   EXPECT_EQ(argument, stub_->argument());
   EXPECT_TRUE(stub_->bypass_address() != NULL);
   EXPECT_EQ(dest_fn, stub_->destination_function());
 }
 
 TEST_F(FunctionStubTest, ZeroArgumentStub) {
   stub_ = FunctionStub::Create(reinterpret_cast<uintptr_t>(this),
                                &FunctionStubTest::FooCallback0);
 
@@ skipping 62 matching lines @@
   HMODULE my_module = NULL;
   EXPECT_TRUE(::GetModuleHandleEx(kFlags,
       reinterpret_cast<const wchar_t*>(&kDivertedRetVal),
       &my_module));
 
   // Set our module as signature.
   stub->set_signature(my_module);
   EXPECT_EQ(stub, FunctionStub::FromCode(stub));
 }