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

base/message_loop/message_loop_unittest.cc

 // Copyright 2013 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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 318 matching lines @@
                                   Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
                                              event.Get(),
                                              true,
                                              &order,
                                              false));
   // Let the other thread execute.
   WaitForSingleObject(event.Get(), INFINITE);
   MessageLoop::current()->Run();
 
-  ASSERT_EQ(order.Size(), 17);
+  ASSERT_EQ(17u, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(MESSAGEBOX, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 3, false));
   // When EndDialogFunc is processed, the window is already dismissed, hence no
   // "end" entry.
   EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, true));
   EXPECT_EQ(order.Get(7), TaskItem(QUITMESSAGELOOP, 5, true));
@@ skipping 23 matching lines @@
                                   Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
                                              event.Get(),
                                              false,
                                              &order,
                                              true));
   // Let the other thread execute.
   WaitForSingleObject(event.Get(), INFINITE);
   MessageLoop::current()->Run();
 
-  ASSERT_EQ(order.Size(), 18);
+  ASSERT_EQ(18u, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   // Note that this executes in the MessageBox modal loop.
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(5), TaskItem(ENDDIALOG, 4, true));
   EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, false));
   EXPECT_EQ(order.Get(7), TaskItem(MESSAGEBOX, 2, false));
   /* The order can subtly change here. The reason is that when RecursiveFunc(1)
@@ skipping 121 matching lines @@
   file_.Set(CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING,
                        FILE_FLAG_OVERLAPPED, NULL));
   EXPECT_TRUE(file_.IsValid());
 }
 
 void TestIOHandler::Init() {
   MessageLoopForIO::current()->RegisterIOHandler(file_.Get(), this);
 
   DWORD read;
   EXPECT_FALSE(ReadFile(file_.Get(), buffer_, size(), &read, context()));
-  EXPECT_EQ(ERROR_IO_PENDING, GetLastError());
+  EXPECT_EQ(static_cast<DWORD>(ERROR_IO_PENDING), GetLastError());
   if (wait_)
     WaitForIO();
 }
 
 void TestIOHandler::OnIOCompleted(MessageLoopForIO::IOContext* context,
                                   DWORD bytes_transfered, DWORD error) {
   ASSERT_TRUE(context == &context_);
   ASSERT_TRUE(SetEvent(signal_));
 }
 
@@ skipping 72 matching lines @@
                                               Unretained(&handler2)));
   PlatformThread::Sleep(delay);
 
   // At this time handler1 is waiting to be called, and the thread is waiting
   // on the Init method of handler2, filtering only handler2 callbacks.
 
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server1.Get(), buffer, sizeof(buffer), &written, NULL));
   PlatformThread::Sleep(2 * delay);
-  EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(callback1_called.Get(), 0)) <<
-      "handler1 has not been called";
+  EXPECT_EQ(static_cast<DWORD>(WAIT_TIMEOUT),
+            WaitForSingleObject(callback1_called.Get(), 0))
+      << "handler1 has not been called";
 
   EXPECT_TRUE(WriteFile(server2.Get(), buffer, sizeof(buffer), &written, NULL));
 
   HANDLE objects[2] = { callback1_called.Get(), callback2_called.Get() };
   DWORD result = WaitForMultipleObjects(2, objects, TRUE, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
 }
 
@@ skipping 399 matching lines @@
   loop.SetTaskRunner(new_runner);
 
   scoped_refptr<Foo> foo(new Foo());
   original_runner->PostTask(FROM_HERE,
                             Bind(&Foo::Test1ConstRef, foo.get(), "a"));
   loop.RunUntilIdle();
   EXPECT_EQ(1, foo->test_count());
 }
 
 }  // namespace base