base: Remove the string logging from CHECK().

components/sync/test/fake_server/fake_server.cc

 // Copyright 2014 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 "components/sync/test/fake_server/fake_server.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 100 matching lines @@
 
   // Maps data type IDs to the latest version seen for that type.
   const ModelTypeToVersionMap request_from_version_;
 
   // The minimum version seen among all data types.
   const int min_version_;
 };
 
 std::unique_ptr<UpdateSieve> UpdateSieve::Create(
     const sync_pb::GetUpdatesMessage& get_updates_message) {
-  CHECK_GT(get_updates_message.from_progress_marker_size(), 0)
-      << "A GetUpdates request must have at least one progress marker.";
+  // A GetUpdates request must have at least one progress marker.
+  CHECK_GT(get_updates_message.from_progress_marker_size(), 0);
 
   UpdateSieve::ModelTypeToVersionMap request_from_version;
   int64_t min_version = std::numeric_limits<int64_t>::max();
   for (int i = 0; i < get_updates_message.from_progress_marker_size(); i++) {
     sync_pb::DataTypeProgressMarker marker =
         get_updates_message.from_progress_marker(i);
 
     int64_t version = 0;
     // Let the version remain zero if there is no token or an empty token (the
     // first request for this type).
     if (marker.has_token() && !marker.token().empty()) {
       bool parsed = base::StringToInt64(marker.token(), &version);
-      CHECK(parsed) << "Unable to parse progress marker token.";
+      // Unable to parse progress marker token.
+      CHECK(parsed);
     }
 
     ModelType model_type =
         syncer::GetModelTypeFromSpecificsFieldNumber(marker.data_type_id());
     request_from_version[model_type] = version;
 
     if (version < min_version)
       min_version = version;
   }
 
@@ skipping 99 matching lines @@
   if (!authenticated_) {
     *error_code = 0;
     *response_code = net::HTTP_UNAUTHORIZED;
     *response = string();
     completion_closure.Run();
     return;
   }
 
   sync_pb::ClientToServerMessage message;
   bool parsed = message.ParseFromString(request);
-  CHECK(parsed) << "Unable to parse the ClientToServerMessage.";
+  // Unable to parse the ClientToServerMessage.
+  CHECK(parsed);
 
   sync_pb::ClientToServerResponse response_proto;
 
   if (message.has_store_birthday() &&
       message.store_birthday() != GetStoreBirthday()) {
     response_proto.set_error_code(sync_pb::SyncEnums::NOT_MY_BIRTHDAY);
   } else if (error_type_ != sync_pb::SyncEnums::SUCCESS &&
              ShouldSendTriggeredError()) {
     response_proto.set_error_code(error_type_);
   } else if (triggered_actionable_error_.get() && ShouldSendTriggeredError()) {
@@ skipping 454 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 std::string FakeServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
 }  // namespace fake_server