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

sandbox/win/src/ipc_unittest.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 <stdint.h>
 
 #include "sandbox/win/src/crosscall_client.h"
 #include "sandbox/win/src/crosscall_server.h"
 #include "sandbox/win/src/sharedmem_ipc_client.h"
 #include "sandbox/win/src/sharedmem_ipc_server.h"
@@ skipping 50 matching lines @@
   }
 }
 
 TEST(IPCTest, ChannelMaker) {
   // Test that our testing rig is computing offsets properly. We should have
   // 5 channnels and the offset to the first channel is 108 bytes in 32 bits
   // and 216 in 64 bits.
   size_t channel_start = 0;
   IPCControl* client_control = MakeChannels(12 * 64, 4096, &channel_start);
   ASSERT_TRUE(NULL != client_control);
-  EXPECT_EQ(5, client_control->channels_count);
+  EXPECT_EQ(5u, client_control->channels_count);
 #if defined(_WIN64)
-  EXPECT_EQ(216, channel_start);
+  EXPECT_EQ(216u, channel_start);
 #else
-  EXPECT_EQ(108, channel_start);
+  EXPECT_EQ(108u, channel_start);
 #endif
   delete[] reinterpret_cast<char*>(client_control);
 }
 
 TEST(IPCTest, ClientLockUnlock) {
   // Make 7 channels of kIPCChannelSize (1kb) each. Test that we lock and
   // unlock channels properly.
   size_t base_start = 0;
   IPCControl* client_control =
       MakeChannels(kIPCChannelSize, 4096 * 2, &base_start);
@@ skipping 73 matching lines @@
   SharedMemIPCClient client(mem);
 
   CrossCallReturn answer;
   uint32_t tag1 = 666;
   const wchar_t *text = L"98765 - 43210";
   base::string16 copied_text;
   CrossCallParamsEx* actual_params;
 
   CrossCall(client, tag1, text, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(1, actual_params->GetParamsCount());
+  EXPECT_EQ(1u, actual_params->GetParamsCount());
   EXPECT_EQ(tag1, actual_params->GetTag());
   EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text));
   EXPECT_STREQ(text, copied_text.c_str());
 
   // Check with an empty string.
   uint32_t tag2 = 777;
   const wchar_t* null_text = NULL;
   CrossCall(client, tag2, null_text, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(1, actual_params->GetParamsCount());
+  EXPECT_EQ(1u, actual_params->GetParamsCount());
   EXPECT_EQ(tag2, actual_params->GetTag());
   uint32_t param_size = 1;
   ArgType type = INVALID_TYPE;
   void* param_addr = actual_params->GetRawParameter(0, &param_size, &type);
   EXPECT_TRUE(NULL != param_addr);
-  EXPECT_EQ(0, param_size);
+  EXPECT_EQ(0u, param_size);
   EXPECT_EQ(WCHAR_TYPE, type);
   EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text));
 
   uint32_t tag3 = 888;
   param_size = 1;
   copied_text.clear();
 
   // Check with an empty string and a non-empty string.
   CrossCall(client, tag3, null_text, text, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(2, actual_params->GetParamsCount());
+  EXPECT_EQ(2u, actual_params->GetParamsCount());
   EXPECT_EQ(tag3, actual_params->GetTag());
   type = INVALID_TYPE;
   param_addr = actual_params->GetRawParameter(0, &param_size, &type);
   EXPECT_TRUE(NULL != param_addr);
-  EXPECT_EQ(0, param_size);
+  EXPECT_EQ(0u, param_size);
   EXPECT_EQ(WCHAR_TYPE, type);
   EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text));
   EXPECT_TRUE(actual_params->GetParameterStr(1, &copied_text));
   EXPECT_STREQ(text, copied_text.c_str());
 
   param_size = 1;
   base::string16 copied_text_p0, copied_text_p2;
 
   const wchar_t *text2 = L"AeFG";
   CrossCall(client, tag1, text2, null_text, text, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(3, actual_params->GetParamsCount());
+  EXPECT_EQ(3u, actual_params->GetParamsCount());
   EXPECT_EQ(tag1, actual_params->GetTag());
   EXPECT_TRUE(actual_params->GetParameterStr(0, &copied_text_p0));
   EXPECT_STREQ(text2, copied_text_p0.c_str());
   EXPECT_TRUE(actual_params->GetParameterStr(2, &copied_text_p2));
   EXPECT_STREQ(text, copied_text_p2.c_str());
   type = INVALID_TYPE;
   param_addr = actual_params->GetRawParameter(1, &param_size, &type);
   EXPECT_TRUE(NULL != param_addr);
-  EXPECT_EQ(0, param_size);
+  EXPECT_EQ(0u, param_size);
   EXPECT_EQ(WCHAR_TYPE, type);
 
   CloseChannelEvents(client_control);
   delete[] reinterpret_cast<char*>(client_control);
 }
 
 TEST(IPCTest, CrossCallIntPacking) {
   // Check handling for regular 32 bit integers used in Windows.
   size_t base_start = 0;
   IPCControl* client_control =
       MakeChannels(kIPCChannelSize, 4096 * 4, &base_start);
   client_control->server_alive = HANDLE(1);
   FixChannels(client_control, base_start, kIPCChannelSize, FIX_PONG_READY);
 
   uint32_t tag1 = 999;
   uint32_t tag2 = 111;
   const wchar_t *text = L"godzilla";
   CrossCallParamsEx* actual_params;
 
   char* mem = reinterpret_cast<char*>(client_control);
   SharedMemIPCClient client(mem);
 
   CrossCallReturn answer;
   DWORD dw = 0xE6578;
   CrossCall(client, tag2, dw, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(1, actual_params->GetParamsCount());
+  EXPECT_EQ(1u, actual_params->GetParamsCount());
   EXPECT_EQ(tag2, actual_params->GetTag());
   ArgType type = INVALID_TYPE;
   uint32_t param_size = 1;
   void* param_addr = actual_params->GetRawParameter(0, &param_size, &type);
   ASSERT_EQ(sizeof(dw), param_size);
   EXPECT_EQ(UINT32_TYPE, type);
   ASSERT_TRUE(NULL != param_addr);
   EXPECT_EQ(0, memcmp(&dw, param_addr, param_size));
 
   // Check handling for windows HANDLES.
   HANDLE h = HANDLE(0x70000500);
   CrossCall(client, tag1, text, h, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(2, actual_params->GetParamsCount());
+  EXPECT_EQ(2u, actual_params->GetParamsCount());
   EXPECT_EQ(tag1, actual_params->GetTag());
   type = INVALID_TYPE;
   param_addr = actual_params->GetRawParameter(1, &param_size, &type);
   ASSERT_EQ(sizeof(h), param_size);
   EXPECT_EQ(VOIDPTR_TYPE, type);
   ASSERT_TRUE(NULL != param_addr);
   EXPECT_EQ(0, memcmp(&h, param_addr, param_size));
 
   // Check combination of 32 and 64 bits.
   CrossCall(client, tag2, h, dw, h, &answer);
   actual_params = reinterpret_cast<CrossCallParamsEx*>(client.GetBuffer());
-  EXPECT_EQ(3, actual_params->GetParamsCount());
+  EXPECT_EQ(3u, actual_params->GetParamsCount());
   EXPECT_EQ(tag2, actual_params->GetTag());
   type = INVALID_TYPE;
   param_addr = actual_params->GetRawParameter(0, &param_size, &type);
   ASSERT_EQ(sizeof(h), param_size);
   EXPECT_EQ(VOIDPTR_TYPE, type);
   ASSERT_TRUE(NULL != param_addr);
   EXPECT_EQ(0, memcmp(&h, param_addr, param_size));
   type = INVALID_TYPE;
   param_addr = actual_params->GetRawParameter(1, &param_size, &type);
   ASSERT_EQ(sizeof(dw), param_size);
@@ skipping 20 matching lines @@
   params_1.CopyParamIn(0, &value, sizeof(value), false, UINT32_TYPE);
   void* buffer = const_cast<void*>(params_1.GetBuffer());
 
   uint32_t out_size = 0;
   CrossCallParamsEx* ccp = 0;
   ccp = CrossCallParamsEx::CreateFromBuffer(buffer, params_1.GetSize(),
                                             &out_size);
   ASSERT_TRUE(NULL != ccp);
   EXPECT_TRUE(ccp->GetBuffer() != buffer);
   EXPECT_EQ(kTag, ccp->GetTag());
-  EXPECT_EQ(1, ccp->GetParamsCount());
+  EXPECT_EQ(1u, ccp->GetParamsCount());
   delete[] (reinterpret_cast<char*>(ccp));
 
   // Test that we handle integer overflow on the number of params
   // correctly. We use a test-only ctor for ActualCallParams that
   // allows to create malformed cross-call buffers.
   const int32_t kPtrDiffSz = sizeof(ptrdiff_t);
   for (int32_t ix = -1; ix != 3; ++ix) {
     uint32_t fake_num_params = (UINT32_MAX / kPtrDiffSz) + ix;
     ActualCallParams<1, kBufferSize> params_2(kTag, fake_num_params);
     params_2.CopyParamIn(0, &value, sizeof(value), false, UINT32_TYPE);
@@ skipping 100 matching lines @@
   EXPECT_EQ(kBusyChannel, client_control->channels[0].state);
   EXPECT_EQ(kFreeChannel, client_control->channels[1].state);
   EXPECT_EQ(kFreeChannel, client_control->channels[2].state);
 
   void* buff1 = client.GetBuffer();
   EXPECT_TRUE(mem + client_control->channels[1].channel_base == buff1);
   EXPECT_EQ(kBusyChannel, client_control->channels[0].state);
   EXPECT_EQ(kBusyChannel, client_control->channels[1].state);
   EXPECT_EQ(kFreeChannel, client_control->channels[2].state);
 
-  EXPECT_EQ(0, client_control->channels[1].ipc_tag);
+  EXPECT_EQ(0u, client_control->channels[1].ipc_tag);
 
   uint32_t tag = 7654;
   CrossCallReturn answer;
   CrossCallParamsMock* params1 = new(buff1) CrossCallParamsMock(tag, 1);
   FakeOkAnswerInChannel(buff1);
 
   ResultCode result = client.DoCall(params1, &answer);
   if (SBOX_ERROR_CHANNEL_ERROR != result)
     client.FreeBuffer(buff1);
 
@@ skipping 174 matching lines @@
                                                  &call_return));
   EXPECT_EQ(SBOX_ALL_OK, call_return.call_outcome);
   EXPECT_TRUE(bar == call_return.extended[0].handle);
   EXPECT_EQ(foo, call_return.extended[1].unsigned_int);
 
   CloseChannelEvents(client_control);
   delete[] reinterpret_cast<char*>(client_control);
 }
 
 }  // namespace sandbox