base: Remove the string logging from CHECK().

sandbox/linux/bpf_dsl/codegen.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 "sandbox/linux/bpf_dsl/codegen.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 62 matching lines @@
     *node = AppendInstruction(code, k, jt, jf);
   }
   return *node;
 }
 
 CodeGen::Node CodeGen::AppendInstruction(uint16_t code,
                                          uint32_t k,
                                          Node jt,
                                          Node jf) {
   if (BPF_CLASS(code) == BPF_JMP) {
-    CHECK_NE(BPF_JA, BPF_OP(code)) << "CodeGen inserts JAs as needed";
+    // CodeGen inserts JAs as needed
+    CHECK_NE(BPF_JA, BPF_OP(code));
 
     // Optimally adding jumps is rather tricky, so we use a quick
     // approximation: by artificially reducing |jt|'s range, |jt| will
     // stay within its true range even if we add a jump for |jf|.
     jt = WithinRange(jt, kBranchRange - 1);
     jf = WithinRange(jf, kBranchRange);
     return Append(code, k, Offset(jt), Offset(jf));
   }
 
-  CHECK_EQ(kNullNode, jf) << "Non-branch instructions shouldn't provide jf";
+  // Non-branch instructions shouldn't provide jf
+  CHECK_EQ(kNullNode, jf);
   if (BPF_CLASS(code) == BPF_RET) {
-    CHECK_EQ(kNullNode, jt) << "Return instructions shouldn't provide jt";
+    // Return instructions shouldn't provide jt
+    CHECK_EQ(kNullNode, jt);
   } else {
     // For non-branch/non-return instructions, execution always
     // proceeds to the next instruction; so we need to arrange for
     // that to be |jt|.
     jt = WithinRange(jt, 0);
-    CHECK_EQ(0U, Offset(jt)) << "ICE: Failed to setup next instruction";
+    // ICE: Failed to setup next instruction
+    CHECK_EQ(0U, Offset(jt));
   }
   return Append(code, k, 0, 0);
 }
 
 CodeGen::Node CodeGen::WithinRange(Node target, size_t range) {
   // Just use |target| if it's already within range.
   if (Offset(target) <= range) {
     return target;
   }
 
@@ skipping 21 matching lines @@
   CHECK_EQ(program_.size(), equivalent_.size());
 
   Node res = program_.size();
   program_.push_back(sock_filter{
       code, static_cast<uint8_t>(jt), static_cast<uint8_t>(jf), k});
   equivalent_.push_back(res);
   return res;
 }
 
 size_t CodeGen::Offset(Node target) const {
-  CHECK_LT(target, program_.size()) << "Bogus offset target node";
+  // Bogus offset target node
+  CHECK_LT(target, program_.size());
   return (program_.size() - 1) - target;
 }
 
 }  // namespace sandbox