clang/mac: Fix almost all problems when building all.xcodeproj.

BUG=None
TEST=None
TBR=hans

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@61344 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 70 insertions, 121 deletions

diff --git a/net/base/cookie_monster_unittest.cc b/net/base/cookie_monster_unittest.cc
index 34a9635..f4cca57 100644
--- a/net/base/cookie_monster_unittest.cc
+++ b/net/base/cookie_monster_unittest.cc
@@ -1518,16 +1518,16 @@ TEST(CookieMonsterTest, Delegate) {
   EXPECT_TRUE(cm->SetCookie(url_google, "E=F"));
   EXPECT_EQ("A=B; C=D; E=F", cm->GetCookies(url_google));
   ASSERT_EQ(3u, delegate->changes().size());
-  EXPECT_EQ(false, delegate->changes()[0].second);
+  EXPECT_FALSE(delegate->changes()[0].second);
   EXPECT_EQ(url_google.host(), delegate->changes()[0].first.Domain());
   EXPECT_EQ("A", delegate->changes()[0].first.Name());
   EXPECT_EQ("B", delegate->changes()[0].first.Value());
   EXPECT_EQ(url_google.host(), delegate->changes()[1].first.Domain());
-  EXPECT_EQ(false, delegate->changes()[1].second);
+  EXPECT_FALSE(delegate->changes()[1].second);
   EXPECT_EQ("C", delegate->changes()[1].first.Name());
   EXPECT_EQ("D", delegate->changes()[1].first.Value());
   EXPECT_EQ(url_google.host(), delegate->changes()[2].first.Domain());
-  EXPECT_EQ(false, delegate->changes()[2].second);
+  EXPECT_FALSE(delegate->changes()[2].second);
   EXPECT_EQ("E", delegate->changes()[2].first.Name());
   EXPECT_EQ("F", delegate->changes()[2].first.Value());
   delegate->reset();
@@ -1536,7 +1536,7 @@ TEST(CookieMonsterTest, Delegate) {
   EXPECT_EQ("A=B; E=F", cm->GetCookies(url_google));
   ASSERT_EQ(1u, delegate->changes().size());
   EXPECT_EQ(url_google.host(), delegate->changes()[0].first.Domain());
-  EXPECT_EQ(true, delegate->changes()[0].second);
+  EXPECT_TRUE(delegate->changes()[0].second);
   EXPECT_EQ("C", delegate->changes()[0].first.Name());
   EXPECT_EQ("D", delegate->changes()[0].first.Value());
   delegate->reset();
@@ -1552,7 +1552,7 @@ TEST(CookieMonsterTest, Delegate) {
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   ASSERT_EQ(1u, delegate->changes().size());
-  EXPECT_EQ(false, delegate->changes()[0].second);
+  EXPECT_FALSE(delegate->changes()[0].second);
   EXPECT_EQ(url_google.host(), delegate->changes()[0].first.Domain());
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
@@ -1572,11 +1572,11 @@ TEST(CookieMonsterTest, Delegate) {
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   ASSERT_EQ(2u, delegate->changes().size());
   EXPECT_EQ(url_google.host(), delegate->changes()[0].first.Domain());
-  EXPECT_EQ(true, delegate->changes()[0].second);
+  EXPECT_TRUE(delegate->changes()[0].second);
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
   EXPECT_EQ(url_google.host(), delegate->changes()[1].first.Domain());
-  EXPECT_EQ(false, delegate->changes()[1].second);
+  EXPECT_FALSE(delegate->changes()[1].second);
   EXPECT_EQ("a", delegate->changes()[1].first.Name());
   EXPECT_EQ("val2", delegate->changes()[1].first.Value());
   delegate->reset();
diff --git a/net/base/mime_util_unittest.cc b/net/base/mime_util_unittest.cc
index 51b7f3a..d4f3a3f 100644
--- a/net/base/mime_util_unittest.cc
+++ b/net/base/mime_util_unittest.cc
@@ -62,39 +62,35 @@ TEST(MimeUtilTest, FileTest) {
 }
 
 TEST(MimeUtilTest, LookupTypes) {
-  EXPECT_EQ(true, net::IsSupportedImageMimeType("image/jpeg"));
-  EXPECT_EQ(false, net::IsSupportedImageMimeType("image/lolcat"));
-  EXPECT_EQ(true, net::IsSupportedNonImageMimeType("text/html"));
-  EXPECT_EQ(false, net::IsSupportedNonImageMimeType("text/virus"));
+  EXPECT_TRUE(net::IsSupportedImageMimeType("image/jpeg"));
+  EXPECT_FALSE(net::IsSupportedImageMimeType("image/lolcat"));
+  EXPECT_TRUE(net::IsSupportedNonImageMimeType("text/html"));
+  EXPECT_FALSE(net::IsSupportedNonImageMimeType("text/virus"));
 
-  EXPECT_EQ(true, net::IsSupportedMimeType("image/jpeg"));
-  EXPECT_EQ(false, net::IsSupportedMimeType("image/lolcat"));
-  EXPECT_EQ(true, net::IsSupportedMimeType("text/html"));
-  EXPECT_EQ(false, net::IsSupportedMimeType("text/virus"));
+  EXPECT_TRUE(net::IsSupportedMimeType("image/jpeg"));
+  EXPECT_FALSE(net::IsSupportedMimeType("image/lolcat"));
+  EXPECT_TRUE(net::IsSupportedMimeType("text/html"));
+  EXPECT_FALSE(net::IsSupportedMimeType("text/virus"));
 }
 
 TEST(MimeUtilTest, MatchesMimeType) {
-  EXPECT_EQ(true, net::MatchesMimeType("*", "video/x-mpeg"));
-  EXPECT_EQ(true, net::MatchesMimeType("video/*", "video/x-mpeg"));
-  EXPECT_EQ(true, net::MatchesMimeType("video/x-mpeg", "video/x-mpeg"));
-  EXPECT_EQ(true, net::MatchesMimeType("application/*+xml",
-                                             "application/html+xml"));
-  EXPECT_EQ(true, net::MatchesMimeType("application/*+xml",
-                                             "application/+xml"));
-  EXPECT_EQ(true, net::MatchesMimeType("aaa*aaa",
-                                             "aaaaaa"));
-  EXPECT_EQ(false, net::MatchesMimeType("video/", "video/x-mpeg"));
-  EXPECT_EQ(false, net::MatchesMimeType("", "video/x-mpeg"));
-  EXPECT_EQ(false, net::MatchesMimeType("", ""));
-  EXPECT_EQ(false, net::MatchesMimeType("video/x-mpeg", ""));
-  EXPECT_EQ(false, net::MatchesMimeType("application/*+xml",
-                                              "application/xml"));
-  EXPECT_EQ(false, net::MatchesMimeType("application/*+xml",
-                                              "application/html+xmlz"));
-  EXPECT_EQ(false, net::MatchesMimeType("application/*+xml",
-                                              "applcation/html+xml"));
-  EXPECT_EQ(false, net::MatchesMimeType("aaa*aaa",
-                                              "aaaaa"));
+  EXPECT_TRUE(net::MatchesMimeType("*", "video/x-mpeg"));
+  EXPECT_TRUE(net::MatchesMimeType("video/*", "video/x-mpeg"));
+  EXPECT_TRUE(net::MatchesMimeType("video/x-mpeg", "video/x-mpeg"));
+  EXPECT_TRUE(net::MatchesMimeType("application/*+xml",
+                                   "application/html+xml"));
+  EXPECT_TRUE(net::MatchesMimeType("application/*+xml", "application/+xml"));
+  EXPECT_TRUE(net::MatchesMimeType("aaa*aaa", "aaaaaa"));
+  EXPECT_FALSE(net::MatchesMimeType("video/", "video/x-mpeg"));
+  EXPECT_FALSE(net::MatchesMimeType("", "video/x-mpeg"));
+  EXPECT_FALSE(net::MatchesMimeType("", ""));
+  EXPECT_FALSE(net::MatchesMimeType("video/x-mpeg", ""));
+  EXPECT_FALSE(net::MatchesMimeType("application/*+xml", "application/xml"));
+  EXPECT_FALSE(net::MatchesMimeType("application/*+xml",
+                                    "application/html+xmlz"));
+  EXPECT_FALSE(net::MatchesMimeType("application/*+xml",
+                                    "applcation/html+xml"));
+  EXPECT_FALSE(net::MatchesMimeType("aaa*aaa", "aaaaa"));
 }
 
 // Note: codecs should only be a list of 2 or fewer; hence the restriction of
diff --git a/net/base/net_log_unittest.h b/net/base/net_log_unittest.h
index 77a9cbd7..5e77275 100644
--- a/net/base/net_log_unittest.h
+++ b/net/base/net_log_unittest.h
@@ -28,7 +28,9 @@ inline ::testing::AssertionResult LogContainsEventHelper(
     NetLog::EventType expected_event,
     NetLog::EventPhase expected_phase) {
   // Negative indices are reverse indices.
-  size_t j = (i < 0) ? entries.size() + i : i;
+  size_t j = (i < 0) ?
+      static_cast<size_t>(static_cast<int>(entries.size()) + i) :
+      static_cast<size_t>(i);
   if (j >= entries.size())
     return ::testing::AssertionFailure() << j << " is out of bounds.";
   const CapturingNetLog::Entry& entry = entries[j];
@@ -95,7 +97,9 @@ inline ::testing::AssertionResult LogContainsEntryWithType(
     int i, // Negative indices are reverse indices.
     NetLog::EventType type) {
   // Negative indices are reverse indices.
-  size_t j = (i < 0) ? entries.size() + i : i;
+  size_t j = (i < 0) ?
+      static_cast<size_t>(static_cast<int>(entries.size()) + i) :
+      static_cast<size_t>(i);
   if (j >= entries.size())
     return ::testing::AssertionFailure() << j << " is out of bounds.";
   const CapturingNetLog::Entry& entry = entries[j];
diff --git a/net/base/registry_controlled_domain_unittest.cc b/net/base/registry_controlled_domain_unittest.cc
index 09c173b..8c90c99 100644
--- a/net/base/registry_controlled_domain_unittest.cc
+++ b/net/base/registry_controlled_domain_unittest.cc
@@ -213,30 +213,30 @@ TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) {
   TestRegistryControlledDomainService::UseDomainData(
       Perfect_Hash_Test2::FindDomain);
 
-  EXPECT_EQ(true, CompareDomains("http://a.b.bar.jp/file.html",
-                                 "http://a.b.bar.jp/file.html")); // b.bar.jp
-  EXPECT_EQ(true, CompareDomains("http://a.b.bar.jp/file.html",
-                                 "http://b.b.bar.jp/file.html")); // b.bar.jp
-  EXPECT_EQ(false, CompareDomains("http://a.foo.jp/file.html",    // foo.jp
-                                  "http://a.not.jp/file.html"));  // not.jp
-  EXPECT_EQ(false, CompareDomains("http://a.foo.jp/file.html",    // foo.jp
-                                  "http://a.foo.jp./file.html")); // foo.jp.
-  EXPECT_EQ(false, CompareDomains("http://a.com/file.html",       // a.com
-                                  "http://b.com/file.html"));     // b.com
-  EXPECT_EQ(true, CompareDomains("http://a.x.com/file.html",
-                                 "http://b.x.com/file.html"));    // x.com
-  EXPECT_EQ(true, CompareDomains("http://a.x.com/file.html",
-                                 "http://.x.com/file.html"));     // x.com
-  EXPECT_EQ(true, CompareDomains("http://a.x.com/file.html",
-                                 "http://..b.x.com/file.html"));  // x.com
-  EXPECT_EQ(true, CompareDomains("http://intranet/file.html",
-                                 "http://intranet/file.html"));   // intranet
-  EXPECT_EQ(true, CompareDomains("http://127.0.0.1/file.html",
-                                 "http://127.0.0.1/file.html"));  // 127.0.0.1
-  EXPECT_EQ(false, CompareDomains("http://192.168.0.1/file.html", // 192.168.0.1
-                                  "http://127.0.0.1/file.html")); // 127.0.0.1
-  EXPECT_EQ(false, CompareDomains("file:///C:/file.html",
-                                  "file:///C:/file.html"));       // no host
+  EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
+                             "http://a.b.bar.jp/file.html")); // b.bar.jp
+  EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
+                             "http://b.b.bar.jp/file.html")); // b.bar.jp
+  EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",    // foo.jp
+                              "http://a.not.jp/file.html"));  // not.jp
+  EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",    // foo.jp
+                              "http://a.foo.jp./file.html")); // foo.jp.
+  EXPECT_FALSE(CompareDomains("http://a.com/file.html",       // a.com
+                              "http://b.com/file.html"));     // b.com
+  EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
+                             "http://b.x.com/file.html"));    // x.com
+  EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
+                             "http://.x.com/file.html"));     // x.com
+  EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
+                             "http://..b.x.com/file.html"));  // x.com
+  EXPECT_TRUE(CompareDomains("http://intranet/file.html",
+                             "http://intranet/file.html"));   // intranet
+  EXPECT_TRUE(CompareDomains("http://127.0.0.1/file.html",
+                             "http://127.0.0.1/file.html"));  // 127.0.0.1
+  EXPECT_FALSE(CompareDomains("http://192.168.0.1/file.html", // 192.168.0.1
+                              "http://127.0.0.1/file.html")); // 127.0.0.1
+  EXPECT_FALSE(CompareDomains("file:///C:/file.html",
+                              "file:///C:/file.html"));       // no host
 }
 
 TEST_F(RegistryControlledDomainTest, TestDefaultData) {
diff --git a/net/base/ssl_config_service_mac_unittest.cc b/net/base/ssl_config_service_mac_unittest.cc
index 0aa06f9..c94f213 100644
--- a/net/base/ssl_config_service_mac_unittest.cc
+++ b/net/base/ssl_config_service_mac_unittest.cc
@@ -38,10 +38,10 @@ class SSLConfigServiceMacTest : public testing::Test {
 TEST(SSLConfigServiceMacTest, GetNowTest) {
   // Verify that the constructor sets the correct default values.
   net::SSLConfig config;
-  EXPECT_EQ(true, config.rev_checking_enabled);
-  EXPECT_EQ(false, config.ssl2_enabled);
-  EXPECT_EQ(true, config.ssl3_enabled);
-  EXPECT_EQ(true, config.tls1_enabled);
+  EXPECT_TRUE(config.rev_checking_enabled);
+  EXPECT_FALSE(config.ssl2_enabled);
+  EXPECT_TRUE(config.ssl3_enabled);
+  EXPECT_TRUE(config.tls1_enabled);
 
   bool rv = net::SSLConfigServiceMac::GetSSLConfigNow(&config);
   EXPECT_TRUE(rv);
diff --git a/net/disk_cache/mapped_file_unittest.cc b/net/disk_cache/mapped_file_unittest.cc
index 8b01a7d..5802671 100644
--- a/net/disk_cache/mapped_file_unittest.cc
+++ b/net/disk_cache/mapped_file_unittest.cc
@@ -36,28 +36,6 @@ void FileCallbackTest::OnFileIOComplete(int bytes_copied) {
   g_cache_tests_received++;
 }
 
-// Wait up to 2 secs without callbacks, or until we receive expected callbacks.
-void WaitForCallbacks(int expected) {
-  if (!expected)
-    return;
-
-#if defined(OS_WIN)
-  int iterations = 0;
-  int last = 0;
-  while (iterations < 40) {
-    SleepEx(50, TRUE);
-    if (expected == g_cache_tests_received)
-      return;
-    if (last == g_cache_tests_received)
-      iterations++;
-    else
-      iterations = 0;
-  }
-#elif defined(OS_POSIX)
-  // TODO(rvargas): Do something when async IO is implemented.
-#endif
-}
-
 }  // namespace
 
 TEST_F(DiskCacheTest, MappedFile_SyncIO) {
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index ad41eac..02d4a5f 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -3814,7 +3814,7 @@ TEST_F(HttpNetworkTransactionTest, ResetStateForRestart) {
   EXPECT_EQ(0U, trans->request_headers_.size());
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_TRUE(response->headers.get() == NULL);
-  EXPECT_EQ(false, response->was_cached);
+  EXPECT_FALSE(response->was_cached);
   EXPECT_EQ(0, response->ssl_info.cert_status);
   EXPECT_FALSE(response->vary_data.is_valid());
 }
diff --git a/net/http/mock_gssapi_library_posix.cc b/net/http/mock_gssapi_library_posix.cc
index d0a46b1..ec69964 100644
--- a/net/http/mock_gssapi_library_posix.cc
+++ b/net/http/mock_gssapi_library_posix.cc
@@ -52,21 +52,6 @@ void CopyOid(gss_OID dest, const gss_OID_desc* src) {
   SetOid(dest, src->elements, src->length);
 }
 
-std::string OidToString(const gss_OID src) {
-  std::string dest;
-  if (!src)
-    return dest;
-  const char* string = reinterpret_cast<char*>(src->elements);
-  dest.assign(string, src->length);
-  return dest;
-}
-
-void OidFromString(const std::string& src, gss_OID dest) {
-  if (!dest)
-    return;
-  SetOid(dest, src.c_str(), src.length());
-}
-
 // gss_buffer_t helpers.
 void ClearBuffer(gss_buffer_t dest) {
   if (!dest)
@@ -132,20 +117,6 @@ void SetName(gss_name_t dest, const void* src, size_t length) {
   name->name.assign(reinterpret_cast<const char*>(src), length);
 }
 
-void CopyName(gss_name_t dest, const gss_name_t src) {
-  if (!dest)
-    return;
-  ClearName(dest);
-  if (!src)
-    return;
-  test::GssNameMockImpl* name_dst =
-      reinterpret_cast<test::GssNameMockImpl*>(dest);
-  test::GssNameMockImpl* name_src =
-      reinterpret_cast<test::GssNameMockImpl*>(dest);
-  name_dst->name = name_src->name;
-  CopyOid(&name_dst->name_type, &name_src->name_type);
-}
-
 std::string NameToString(const gss_name_t& src) {
   std::string dest;
   if (!src)
diff --git a/net/http/url_security_manager_unittest.cc b/net/http/url_security_manager_unittest.cc
index 45d93c9..d1e7623 100644
--- a/net/http/url_security_manager_unittest.cc
+++ b/net/http/url_security_manager_unittest.cc
@@ -88,7 +88,7 @@ TEST(URLSecurityManager, CanDelegate_NoWhitelist) {
   for (size_t i = 0; i < arraysize(kTestDataList); ++i) {
     GURL gurl(kTestDataList[i].url);
     bool can_delegate = url_security_manager->CanDelegate(gurl);
-    EXPECT_EQ(false, can_delegate);
+    EXPECT_FALSE(can_delegate);
   }
 }
 
diff --git a/net/spdy/spdy_protocol_test.cc b/net/spdy/spdy_protocol_test.cc
index e0b0591..40ba3df 100644
--- a/net/spdy/spdy_protocol_test.cc
+++ b/net/spdy/spdy_protocol_test.cc
@@ -72,13 +72,13 @@ TEST(SpdyProtocolTest, FrameStructs) {
   frame.set_flags(10);
   EXPECT_EQ(12345u, frame.length());
   EXPECT_EQ(10u, frame.flags());
-  EXPECT_EQ(false, frame.is_control_frame());
+  EXPECT_FALSE(frame.is_control_frame());
 
   frame.set_length(0);
   frame.set_flags(10);
   EXPECT_EQ(0u, frame.length());
   EXPECT_EQ(10u, frame.flags());
-  EXPECT_EQ(false, frame.is_control_frame());
+  EXPECT_FALSE(frame.is_control_frame());
 }
 
 TEST(SpdyProtocolTest, DataFrameStructs) {