base: Remove the string logging from CHECK().

net/socket/socket_test_util.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 "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 215 matching lines @@
   EXPECT_EQ(expected_data, actual_data);
   return expected_data == actual_data;
 }
 
 const MockWrite& StaticSocketDataHelper::PeekRealWrite() const {
   for (size_t i = write_index_; i < write_count_; i++) {
     if (writes_[i].mode != ASYNC || writes_[i].result != ERR_IO_PENDING)
       return writes_[i];
   }
 
-  CHECK(false) << "No write data available.";
+  // No write data available.
+  CHECK(false);
   return writes_[0];  // Avoid warning about unreachable missing return.
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider()
     : StaticSocketDataProvider(nullptr, 0, nullptr, 0) {
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads,
                                                    size_t reads_count,
                                                    MockWrite* writes,
@@ skipping 83 matching lines @@
   size_t next_read = 0;
   size_t next_write = 0;
   int next_sequence_number = 0;
   bool last_event_was_pause = false;
   while (next_read < reads_count || next_write < writes_count) {
     if (next_read < reads_count &&
         reads[next_read].sequence_number == next_sequence_number) {
       // Check if this is a pause.
       if (reads[next_read].mode == ASYNC &&
           reads[next_read].result == ERR_IO_PENDING) {
-        CHECK(!last_event_was_pause) << "Two pauses in a row are not allowed: "
-                                     << next_sequence_number;
+        // Two pauses in a row are not allowed.
+        CHECK(!last_event_was_pause);
         last_event_was_pause = true;
       } else if (last_event_was_pause) {
-        CHECK_EQ(ASYNC, reads[next_read].mode)
-            << "A sync event after a pause makes no sense: "
-            << next_sequence_number;
-        CHECK_NE(ERR_IO_PENDING, reads[next_read].result)
-            << "A pause event after a pause makes no sense: "
-            << next_sequence_number;
+        // A sync event after a pause makes no sense.
+        CHECK_EQ(ASYNC, reads[next_read].mode);
+        // A pause event after a pause makes no sense.
+        CHECK_NE(ERR_IO_PENDING, reads[next_read].result);
         last_event_was_pause = false;
       }
 
       ++next_read;
       ++next_sequence_number;
       continue;
     }
     if (next_write < writes_count &&
         writes[next_write].sequence_number == next_sequence_number) {
       // Check if this is a pause.
       if (writes[next_write].mode == ASYNC &&
           writes[next_write].result == ERR_IO_PENDING) {
-        CHECK(!last_event_was_pause) << "Two pauses in a row are not allowed: "
-                                     << next_sequence_number;
+        // Two pauses in a row are not allowed.
+        CHECK(!last_event_was_pause);
         last_event_was_pause = true;
       } else if (last_event_was_pause) {
-        CHECK_EQ(ASYNC, writes[next_write].mode)
-            << "A sync event after a pause makes no sense: "
-            << next_sequence_number;
-        CHECK_NE(ERR_IO_PENDING, writes[next_write].result)
-            << "A pause event after a pause makes no sense: "
-            << next_sequence_number;
+        // A sync event after a pause makes no sense.
+        CHECK_EQ(ASYNC, writes[next_write].mode);
+        // A pause event after a pause makes no sense.
+        CHECK_NE(ERR_IO_PENDING, writes[next_write].result);
         last_event_was_pause = false;
       }
 
       ++next_write;
       ++next_sequence_number;
       continue;
     }
-    CHECK(false) << "Sequence number not found where expected: "
-                 << next_sequence_number;
+    // Sequence number not found where expected.
+    CHECK(false);
     return;
   }
 
   // Last event must not be a pause.  For the final event to indicate the
   // operation never completes, it should be SYNCHRONOUS and return
   // ERR_IO_PENDING.
   CHECK(!last_event_was_pause);
 
   CHECK_EQ(next_read, reads_count);
   CHECK_EQ(next_write, writes_count);
@@ skipping 1353 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net