mac: Prepare most test code for -Wunused-functions too.

chrome/browser/ui/webui/sync_setup_handler_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/browser/ui/webui/sync_setup_handler.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 79 matching lines @@
   result.SetBoolean("passwordsSynced", types.Has(syncer::PASSWORDS));
   result.SetBoolean("preferencesSynced", types.Has(syncer::PREFERENCES));
   result.SetBoolean("tabsSynced", types.Has(syncer::PROXY_TABS));
   result.SetBoolean("themesSynced", types.Has(syncer::THEMES));
   result.SetBoolean("typedUrlsSynced", types.Has(syncer::TYPED_URLS));
   std::string args;
   base::JSONWriter::Write(&result, &args);
   return args;
 }
 
-void CheckInt(const DictionaryValue* dictionary,
-              const std::string& key,
-              int expected_value) {
-  int actual_value;
-  EXPECT_TRUE(dictionary->GetInteger(key, &actual_value)) <<
-      "Did not expect to find value for " << key;
-  EXPECT_EQ(actual_value, expected_value) <<
-      "Mismatch found for " << key;
-}
-
 // Checks whether the passed |dictionary| contains a |key| with the given
 // |expected_value|. If |omit_if_false| is true, then the value should only
 // be present if |expected_value| is true.
 void CheckBool(const DictionaryValue* dictionary,
                const std::string& key,
                bool expected_value,
                bool omit_if_false) {
   if (omit_if_false && !expected_value) {
     EXPECT_FALSE(dictionary->HasKey(key)) <<
         "Did not expect to find value for " << key;
   } else {
     bool actual_value;
     EXPECT_TRUE(dictionary->GetBoolean(key, &actual_value)) <<
         "No value found for " << key;
     EXPECT_EQ(actual_value, expected_value) <<
         "Mismatch found for " << key;
   }
 }
 
 void CheckBool(const DictionaryValue* dictionary,
                const std::string& key,
                bool expected_value) {
   return CheckBool(dictionary, key, expected_value, false);
 }
 
-void CheckString(const DictionaryValue* dictionary,
-                 const std::string& key,
-                 const std::string& expected_value,
-                 bool omit_if_empty) {
-  if (omit_if_empty && expected_value.empty()) {
-    EXPECT_FALSE(dictionary->HasKey(key)) <<
-        "Did not expect to find value for " << key;
-  } else {
-    std::string actual_value;
-    EXPECT_TRUE(dictionary->GetString(key, &actual_value)) <<
-        "No value found for " << key;
-    EXPECT_EQ(actual_value, expected_value) <<
-        "Mismatch found for " << key;
-  }
-}
-
 // Checks to make sure that the values stored in |dictionary| match the values
 // expected by the showSyncSetupPage() JS function for a given set of data
 // types.
 void CheckConfigDataTypeArguments(DictionaryValue* dictionary,
                                   SyncAllDataConfig config,
                                   syncer::ModelTypeSet types) {
   CheckBool(dictionary, "syncAllDataTypes", config == SYNC_ALL_DATA);
   CheckBool(dictionary, "syncNothing", config == SYNC_NOTHING);
   CheckBool(dictionary, "appsSynced", types.Has(syncer::APPS));
   CheckBool(dictionary, "autofillSynced", types.Has(syncer::AUTOFILL));
@@ skipping 911 matching lines @@
 
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup();
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }