base: Remove the string logging from CHECK().

components/pairing/fake_controller_pairing_controller.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/pairing/fake_controller_pairing_controller.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 19 matching lines @@
 }
 
 FakeControllerPairingController::~FakeControllerPairingController() {
   RemoveObserver(this);
 }
 
 void FakeControllerPairingController::ApplyConfig(const std::string& config) {
   typedef std::vector<std::string> Tokens;
 
   base::StringPairs kv_pairs;
-  CHECK(base::SplitStringIntoKeyValuePairs(config, ':', ',', &kv_pairs))
-      << "Wrong config format.";
+  // Wrong config format.
+  CHECK(base::SplitStringIntoKeyValuePairs(config, ':', ',', &kv_pairs));
   std::map<std::string, std::string> dict(kv_pairs.begin(), kv_pairs.end());
 
   if (dict.count("async_duration")) {
     int ms = 0;
-    CHECK(base::StringToInt(dict["async_duration"], &ms))
-        << "Wrong 'async_duration' format.";
+    // Wrong 'async_duration' format.
+    CHECK(base::StringToInt(dict["async_duration"], &ms));
     async_duration_ = base::TimeDelta::FromMilliseconds(ms);
   } else {
     async_duration_ = base::TimeDelta::FromMilliseconds(3000);
   }
 
   should_fail_on_connecting_ =
       dict.count("fail_connecting") && (dict["fail_connecting"] == "1");
 
   enrollment_should_fail_ =
       dict.count("fail_enrollment") && (dict["fail_enrollment"] == "1");
 
   if (dict.count("connection_lost")) {
     Tokens lost_begin_end = base::SplitString(
         dict["connection_lost"], "-", base::KEEP_WHITESPACE,
         base::SPLIT_WANT_NONEMPTY);
-    CHECK_EQ(2u, lost_begin_end.size()) << "Wrong 'connection_lost' format.";
+    // Wrong 'connection_lost' format.
+    CHECK_EQ(2u, lost_begin_end.size());
     int begin = 0;
     int end = 0;
+    // Wrong 'connection_lost' format.
     CHECK(base::StringToInt(lost_begin_end[0], &begin) &&
-          base::StringToInt(lost_begin_end[1], &end))
-        << "Wrong 'connection_lost' format.";
+          base::StringToInt(lost_begin_end[1], &end));
+    // Wrong 'connection_lost' interval.
     CHECK((begin == 0 && end == 0) ||
           (STAGE_WAITING_FOR_CODE_CONFIRMATION <= begin && begin <= end &&
-           end <= STAGE_HOST_ENROLLMENT_ERROR))
-        << "Wrong 'connection_lost' interval.";
+           end <= STAGE_HOST_ENROLLMENT_ERROR));
     connection_lost_begin_ = static_cast<Stage>(begin);
     connection_lost_end_ = static_cast<Stage>(end);
   } else {
     connection_lost_begin_ = connection_lost_end_ = STAGE_NONE;
   }
 
   if (!dict.count("discovery")) {
     dict["discovery"] =
         "F-Device_1~F-Device_5~F-Device_3~L-Device_3~L-Device_1~F-Device_1";
   }
   base::StringPairs events;
+  // Wrong 'discovery' format.
   CHECK(
-      base::SplitStringIntoKeyValuePairs(dict["discovery"], '-', '~', &events))
-      << "Wrong 'discovery' format.";
+      base::SplitStringIntoKeyValuePairs(dict["discovery"], '-', '~', &events));
   DiscoveryScenario scenario;
   for (const auto& event : events) {
     const std::string& type = event.first;
     const std::string& device_id = event.second;
-    CHECK(type == "F" || type == "L" || type == "N")
-        << "Wrong discovery event type.";
-    CHECK(!device_id.empty() || type == "N") << "Empty device ID.";
+    // Wrong discovery event type.
+    CHECK(type == "F" || type == "L" || type == "N");
+    // Empty device ID.
+    CHECK(!device_id.empty() || type == "N");
     scenario.push_back(DiscoveryEvent(
         type == "F" ? DEVICE_FOUND : type == "L" ? DEVICE_LOST : NOTHING_FOUND,
         device_id));
   }
   SetDiscoveryScenario(scenario);
 
   preset_confirmation_code_ = dict["code"];
+  // Wrong 'code' format.
   CHECK(preset_confirmation_code_.empty() ||
         (preset_confirmation_code_.length() == 6 &&
          preset_confirmation_code_.find_first_not_of("0123456789") ==
-             std::string::npos))
-      << "Wrong 'code' format.";
+             std::string::npos));
 }
 
 void FakeControllerPairingController::SetShouldFailOnConnecting() {
   should_fail_on_connecting_ = true;
 }
 
 void FakeControllerPairingController::SetShouldLoseConnection(Stage stage_begin,
                                                               Stage stage_end) {
   connection_lost_begin_ = stage_begin;
   connection_lost_end_ = stage_end;
@@ skipping 221 matching lines @@
     next_stage = STAGE_HOST_CONNECTION_LOST;
   }
   if (next_stage != STAGE_NONE)
     ChangeStageLater(next_stage);
 }
 
 void FakeControllerPairingController::DiscoveredDevicesListChanged() {
 }
 
 }  // namespace pairing_chromeos