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

sandbox/win/src/handle_closer_test.cc

 // Copyright (c) 2011 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 "base/strings/stringprintf.h"
 #include "base/win/scoped_handle.h"
 #include "sandbox/win/src/handle_closer_agent.h"
 #include "sandbox/win/src/nt_internals.h"
 #include "sandbox/win/src/sandbox.h"
 #include "sandbox/win/src/sandbox_factory.h"
@@ skipping 68 matching lines @@
     return SBOX_TEST_FAILED_TO_RUN_TEST;
   bool should_find = argv[0][0] == L'Y';
   if (argv[0][1] != L'\0' || (!should_find && argv[0][0] != L'N'))
     return SBOX_TEST_FAILED_TO_RUN_TEST;
 
   static int state = BEFORE_INIT;
   switch (state++) {
     case BEFORE_INIT:
       // Create a unique marker file that is open while the test is running.
       // The handles leak, but it will be closed by the test or on exit.
-      for (int i = 0; i < arraysize(kFileExtensions); ++i)
-        CHECK_NE(GetMarkerFile(kFileExtensions[i]), INVALID_HANDLE_VALUE);
+      for (const wchar_t* kExtension : kFileExtensions)
+        CHECK_NE(GetMarkerFile(kExtension), INVALID_HANDLE_VALUE);
       return SBOX_TEST_SUCCEEDED;
 
     case AFTER_REVERT: {
       // Brute force the handle table to find what we're looking for.
       DWORD handle_count = UINT_MAX;
       const int kInvalidHandleThreshold = 100;
       const size_t kHandleOffset = 4;  // Handles are always a multiple of 4.
       HANDLE handle = NULL;
       int invalid_count = 0;
       base::string16 handle_name;
@@ skipping 26 matching lines @@
 
 // Checks that supplied handle is an Event and it's not waitable.
 // Format: CheckForEventHandles
 SBOX_TESTS_COMMAND int CheckForEventHandles(int argc, wchar_t** argv) {
   static int state = BEFORE_INIT;
   static std::vector<HANDLE> to_check;
 
   switch (state++) {
     case BEFORE_INIT:
       // Create a unique marker file that is open while the test is running.
-      for (int i = 0; i < arraysize(kFileExtensions); ++i) {
-        HANDLE handle = GetMarkerFile(kFileExtensions[i]);
+      for (const wchar_t* kExtension : kFileExtensions) {
+        HANDLE handle = GetMarkerFile(kExtension);
         CHECK_NE(handle, INVALID_HANDLE_VALUE);
         to_check.push_back(handle);
       }
       return SBOX_TEST_SUCCEEDED;
 
     case AFTER_REVERT:
       for (auto handle : to_check) {
         // Set up buffers for the type info and the name.
         std::vector<BYTE> type_info_buffer(sizeof(OBJECT_TYPE_INFORMATION) +
                                            32 * sizeof(wchar_t));
@@ skipping 39 matching lines @@
 
   return SBOX_TEST_SUCCEEDED;
 }
 
 TEST(HandleCloserTest, CheckForMarkerFiles) {
   TestRunner runner;
   runner.SetTimeout(2000);
   runner.SetTestState(EVERY_STATE);
 
   base::string16 command = base::string16(L"CheckForFileHandles Y");
-  for (int i = 0; i < arraysize(kFileExtensions); ++i) {
+  for (const wchar_t* kExtension : kFileExtensions) {
     base::string16 handle_name;
-    base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i]));
+    base::win::ScopedHandle marker(GetMarkerFile(kExtension));
     CHECK(marker.IsValid());
     CHECK(sandbox::GetHandleName(marker.Get(), &handle_name));
     command += (L" ");
     command += handle_name;
   }
 
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(command.c_str())) <<
     "Failed: " << command;
 }
 
 TEST(HandleCloserTest, CloseMarkerFiles) {
   TestRunner runner;
   runner.SetTimeout(2000);
   runner.SetTestState(EVERY_STATE);
   sandbox::TargetPolicy* policy = runner.GetPolicy();
 
   base::string16 command = base::string16(L"CheckForFileHandles N");
-  for (int i = 0; i < arraysize(kFileExtensions); ++i) {
+  for (const wchar_t* kExtension : kFileExtensions) {
     base::string16 handle_name;
-    base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i]));
+    base::win::ScopedHandle marker(GetMarkerFile(kExtension));
     CHECK(marker.IsValid());
     CHECK(sandbox::GetHandleName(marker.Get(), &handle_name));
     CHECK_EQ(policy->AddKernelObjectToClose(L"File", handle_name.c_str()),
               SBOX_ALL_OK);
     command += (L" ");
     command += handle_name;
   }
 
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(command.c_str())) <<
     "Failed: " << command;
 }
 
 TEST(HandleCloserTest, CheckStuffedHandle) {
   TestRunner runner;
   runner.SetTimeout(2000);
   runner.SetTestState(EVERY_STATE);
   sandbox::TargetPolicy* policy = runner.GetPolicy();
 
-  for (int i = 0; i < arraysize(kFileExtensions); ++i) {
+  for (const wchar_t* kExtension : kFileExtensions) {
     base::string16 handle_name;
-    base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i]));
+    base::win::ScopedHandle marker(GetMarkerFile(kExtension));
     CHECK(marker.IsValid());
     CHECK(sandbox::GetHandleName(marker.Get(), &handle_name));
     CHECK_EQ(policy->AddKernelObjectToClose(L"File", handle_name.c_str()),
              SBOX_ALL_OK);
   }
 
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(L"CheckForEventHandles"));
 }
 
 void WINAPI ThreadPoolTask(void* event, BOOLEAN timeout) {
@@ skipping 36 matching lines @@
   runner.SetTestState(AFTER_REVERT);
   sandbox::TargetPolicy* policy = runner.GetPolicy();
 
   // Sever the CSRSS connection by closing ALPC ports inside the sandbox.
   CHECK_EQ(policy->AddKernelObjectToClose(L"ALPC Port", NULL), SBOX_ALL_OK);
 
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(L"RunThreadPool"));
 }
 
 }  // namespace sandbox