Unsigned warning fix - take 2

sandbox/src/interception_unittest.cc

-// Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
+// 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.
 
 // This file contains unit tests for InterceptionManager.
 // The tests require private information so the whole interception.cc file is
 // included from this file.
 
 #include <windows.h>
 
 #include "base/scoped_ptr.h"
@@ skipping 18 matching lines @@
   ASSERT_TRUE(NULL != buffer);
   ASSERT_TRUE(NULL != num_functions);
   ASSERT_TRUE(NULL != num_names);
   *num_dlls = *num_functions = *num_names = 0;
   SharedMemory *memory = reinterpret_cast<SharedMemory*>(buffer);
 
   ASSERT_GT(size, sizeof(SharedMemory));
   DllPatchInfo *dll = &memory->dll_list[0];
 
   for (int i = 0; i < memory->num_intercepted_dlls; i++) {
-    ASSERT_NE(0, wcslen(dll->dll_name));
-    ASSERT_EQ(0, dll->record_bytes % sizeof(size_t));
-    ASSERT_EQ(0, dll->offset_to_functions % sizeof(size_t));
+    ASSERT_NE(0u, wcslen(dll->dll_name));
+    ASSERT_EQ(0u, dll->record_bytes % sizeof(size_t));
+    ASSERT_EQ(0u, dll->offset_to_functions % sizeof(size_t));
     ASSERT_NE(0, dll->num_functions);
 
     FunctionInfo *function = reinterpret_cast<FunctionInfo*>(
       reinterpret_cast<char*>(dll) + dll->offset_to_functions);
 
     for (int j = 0; j < dll->num_functions; j++) {
-      ASSERT_EQ(0, function->record_bytes % sizeof(size_t));
+      ASSERT_EQ(0u, function->record_bytes % sizeof(size_t));
 
       char* name = function->function;
       size_t length = strlen(name);
-      ASSERT_NE(0, length);
+      ASSERT_NE(0u, length);
       name += length + 1;
 
       // look for overflows
       ASSERT_GT(reinterpret_cast<char*>(buffer) + size, name + strlen(name));
 
       // look for a named interceptor
       if (strlen(name)) {
         (*num_names)++;
         EXPECT_TRUE(NULL == function->interceptor_address);
       } else {
         EXPECT_TRUE(NULL != function->interceptor_address);
       }
 
       (*num_functions)++;
       function = reinterpret_cast<FunctionInfo*>(
         reinterpret_cast<char*>(function) + function->record_bytes);
     }
 
     (*num_dlls)++;
     dll = reinterpret_cast<DllPatchInfo*>(reinterpret_cast<char*>(dll) +
                                           dll->record_bytes);
   }
 }
 
 TEST(InterceptionManagerTest, BufferLayout1) {
   wchar_t exe_name[MAX_PATH];
-  ASSERT_NE(0, GetModuleFileName(NULL, exe_name, MAX_PATH - 1));
+  ASSERT_NE(0u, GetModuleFileName(NULL, exe_name, MAX_PATH - 1));
 
   TargetProcess *target = MakeTestTargetProcess(::GetCurrentProcess(),
                                                 ::GetModuleHandle(exe_name));
 
   InterceptionManager interceptions(target, true);
 
   // Any pointer will do for a function pointer.
   void* function = &interceptions;
 
   // We don't care about the interceptor id.
@@ skipping 66 matching lines @@
   // The 15 interceptions on the buffer (to the child) should be grouped on 6
   // dlls. Only four interceptions are using an explicit name for the
   // interceptor function.
   EXPECT_EQ(6, num_dlls);
   EXPECT_EQ(15, num_functions);
   EXPECT_EQ(4, num_names);
 }
 
 TEST(InterceptionManagerTest, BufferLayout2) {
   wchar_t exe_name[MAX_PATH];
-  ASSERT_NE(0, GetModuleFileName(NULL, exe_name, MAX_PATH - 1));
+  ASSERT_NE(0u, GetModuleFileName(NULL, exe_name, MAX_PATH - 1));
 
   TargetProcess *target = MakeTestTargetProcess(::GetCurrentProcess(),
                                                 ::GetModuleHandle(exe_name));
 
   InterceptionManager interceptions(target, true);
 
   // Any pointer will do for a function pointer.
   void* function = &interceptions;
   interceptions.AddToUnloadModules(L"some01.dll");
   // We don't care about the interceptor id.
@@ skipping 25 matching lines @@
   int num_dlls, num_functions, num_names;
   WalkBuffer(local_buffer.get(), buffer_size, &num_dlls, &num_functions,
              &num_names);
 
   EXPECT_EQ(3, num_dlls);
   EXPECT_EQ(4, num_functions);
   EXPECT_EQ(0, num_names);
 }
 
 }  // namespace sandbox