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

chrome/installer/util/google_update_settings_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 "chrome/installer/util/google_update_settings.h"
 
 #include <windows.h>
 #include <shlwapi.h>  // For SHDeleteKey.
 
 #include "base/base_paths.h"
@@ skipping 82 matching lines @@
     ASSERT_EQ(ERROR_SUCCESS,
               update_key.WriteValue(installer::kUninstallArgumentsField,
                                     L"--multi-install"));
   }
 
   // Tests setting the ap= value to various combinations of values with
   // suffixes, while asserting on the correct channel value.
   // Note that ap= value has to match "^2.0-d.*" or ".*x64-dev.*" and "^1.1-.*"
   // or ".*x64-beta.*" for dev and beta channels respectively.
   void TestCurrentChromeChannelWithVariousApValues(SystemUserInstall install) {
-    static struct Expectations {
+    static struct Expectation {
       const wchar_t* ap_value;
       const wchar_t* channel;
       bool supports_prefixes;
     } expectations[] = {
       { L"2.0-dev", installer::kChromeChannelDev, false},
       { L"1.1-beta", installer::kChromeChannelBeta, false},
       { L"x64-dev", installer::kChromeChannelDev, true},
       { L"x64-beta", installer::kChromeChannelBeta, true},
       { L"x64-stable", installer::kChromeChannelStable, true},
     };
     bool is_system = install == SYSTEM_INSTALL;
     const wchar_t* prefixes[] = {
       L"",
       L"prefix",
       L"prefix-with-dash",
     };
     const wchar_t* suffixes[] = {
       L"",
       L"suffix",
       L"suffix-with-dash",
     };
 
-    for (size_t i = 0; i < arraysize(prefixes); ++i) {
-      for (size_t j = 0; j < arraysize(expectations); ++j) {
-        for (size_t k = 0; k < arraysize(suffixes); ++k) {
-          base::string16 ap = prefixes[i];
-          ap += expectations[j].ap_value;
-          ap += suffixes[k];
-          const wchar_t* channel = expectations[j].channel;
+    for (const wchar_t* prefix : prefixes) {
+      for (const Expectation& expectation : expectations) {
+        for (const wchar_t* suffix : suffixes) {
+          base::string16 ap = prefix;
+          ap += expectation.ap_value;
+          ap += suffix;
+          const wchar_t* channel = expectation.channel;
 
           SetApField(install, ap.c_str());
           base::string16 ret_channel;
 
           EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(
             is_system, &ret_channel));
 
           // If prefixes are not supported for a channel, we expect the channel
           // to be "unknown" if a non-empty prefix is present in ap_value.
-          if (!expectations[j].supports_prefixes && wcslen(prefixes[i]) > 0) {
+          if (!expectation.supports_prefixes && wcslen(prefix) > 0) {
             EXPECT_STREQ(installer::kChromeChannelUnknown, ret_channel.c_str())
                 << "Expecting channel \"" << installer::kChromeChannelUnknown
                 << "\" for ap=\"" << ap << "\"";
           } else {
             EXPECT_STREQ(channel, ret_channel.c_str())
                 << "Expecting channel \"" << channel
                 << "\" for ap=\"" << ap << "\"";
           }
         }
       }
@@ skipping 284 matching lines @@
   };
   static_assert(arraysize(multifail_full) == arraysize(plain),
                 "bad multifail_full array size");
   const wchar_t* const* input_arrays[] = {
     plain,
     full,
     multifail,
     multifail_full
   };
   ChannelInfo v;
-  for (int type_idx = 0; type_idx < arraysize(archive_types); ++type_idx) {
-    const installer::ArchiveType archive_type = archive_types[type_idx];
-    for (int result_idx = 0; result_idx < arraysize(results); ++result_idx) {
-      const int result = results[result_idx];
+  for (const installer::ArchiveType archive_type : archive_types) {
+    for (const int result : results) {
       // The archive type will/must always be known on install success.
       if (archive_type == installer::UNKNOWN_ARCHIVE_TYPE &&
           result == installer::FIRST_INSTALL_SUCCESS) {
         continue;
       }
       const wchar_t* const* outputs = NULL;
       if (result == installer::FIRST_INSTALL_SUCCESS ||
           archive_type == installer::FULL_ARCHIVE_TYPE) {
         outputs = plain;
       } else if (archive_type == installer::INCREMENTAL_ARCHIVE_TYPE) {
         outputs = full;
       }  // else if (archive_type == UNKNOWN) see below
 
-      for (int inputs_idx = 0; inputs_idx < arraysize(input_arrays);
-           ++inputs_idx) {
-        const wchar_t* const* inputs = input_arrays[inputs_idx];
+      for (const wchar_t* const* inputs : input_arrays) {
         if (archive_type == installer::UNKNOWN_ARCHIVE_TYPE) {
           // "-full" is untouched if the archive type is unknown.
           // "-multifail" is unconditionally removed.
           if (inputs == full || inputs == multifail_full)
             outputs = full;
           else
             outputs = plain;
         }
-        for (int input_idx = 0; input_idx < arraysize(plain); ++input_idx) {
+        for (size_t input_idx = 0; input_idx < arraysize(plain); ++input_idx) {
           const wchar_t* input = inputs[input_idx];
           const wchar_t* output = outputs[input_idx];
 
           v.set_value(input);
           if (output == v.value()) {
             EXPECT_FALSE(GoogleUpdateSettings::UpdateGoogleUpdateApKey(
                 archive_type, result, &v))
                 << "archive_type: " << archive_type
                 << ", result: " << result
                 << ", input ap value: " << input;
@@ skipping 227 matching lines @@
       RegKey(HKEY_LOCAL_MACHINE, num_signed_in_path.c_str(),
              KEY_QUERY_VALUE).ReadValueDW(uniquename.c_str(),
                                           &num_signed_in));
   EXPECT_EQ(
       ERROR_SUCCESS,
       RegKey(HKEY_LOCAL_MACHINE, num_signed_in_path.c_str(),
              KEY_QUERY_VALUE).ReadValue(google_update::kRegAggregateMethod,
                                         &aggregate));
 
   // Verify the correct values were written.
-  EXPECT_EQ(3, num_profiles);
-  EXPECT_EQ(2, num_signed_in);
+  EXPECT_EQ(3u, num_profiles);
+  EXPECT_EQ(2u, num_signed_in);
   EXPECT_EQ(L"sum()", aggregate);
 }
 
 TEST_F(GoogleUpdateSettingsTest, UpdateProfileCountsUserInstall) {
   // Unit tests never operate as an installed application, so will never
   // be a system install.
 
   // No profile count values present yet.
   const base::string16& state_key = BrowserDistribution::GetDistribution()->
       GetAppRegistrationData().GetStateKey();
@@ skipping 633 matching lines @@
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::FALSE_SETTING, StatsState::FALSE_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::FALSE_SETTING, StatsState::TRUE_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::TRUE_SETTING, StatsState::NO_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::TRUE_SETTING, StatsState::FALSE_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::TRUE_SETTING, StatsState::TRUE_SETTING)));