base: Remove the string logging from CHECK().

chrome/browser/chromeos/login/screenshot_testing/screenshot_tester.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 "chrome/browser/chromeos/login/screenshot_testing/screenshot_tester.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "ash/shell.h"
@@ skipping 41 matching lines @@
 ScreenshotTester::Result::~Result() {
 }
 
 bool ScreenshotTester::TryInitialize() {
   base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
   if (!command_line.HasSwitch(switches::kEnableScreenshotTestingWithMode))
     return false;
 
   std::string mode = command_line.GetSwitchValueASCII(
       switches::kEnableScreenshotTestingWithMode);
-  CHECK(mode == kUpdateMode || mode == kTestMode || mode == kPdiffTestMode)
-      << "Invalid mode for screenshot testing: " << mode;
+  // Invalid mode for screenshot testing.
+  CHECK(mode == kUpdateMode || mode == kTestMode || mode == kPdiffTestMode);
 
-  CHECK(command_line.HasSwitch(chromeos::switches::kGoldenScreenshotsDir))
-      << "No directory with golden screenshots specified, use "
-         "--golden-screenshots-dir";
+  // No directory with golden screenshots specified, use
+  // --golden-screenshots-dir
+  CHECK(command_line.HasSwitch(chromeos::switches::kGoldenScreenshotsDir));
 
   golden_screenshots_dir_ =
       command_line.GetSwitchValuePath(switches::kGoldenScreenshotsDir);
 
   if (mode == kTestMode || mode == kPdiffTestMode) {
     test_mode_ = true;
     generate_artifacts_ = command_line.HasSwitch(switches::kArtifactsDir);
     if (generate_artifacts_) {
       artifacts_dir_ = command_line.GetSwitchValuePath(switches::kArtifactsDir);
     }
@@ skipping 37 matching lines @@
   }
   return file_path;
 }
 
 void ScreenshotTester::Run(const std::string& test_name) {
   PNGFile current_screenshot = TakeScreenshot();
   base::FilePath golden_screenshot_path =
       GetImageFilePath(test_name, kGoldenScreenshot);
   PNGFile golden_screenshot = LoadGoldenScreenshot(golden_screenshot_path);
   if (test_mode_) {
-    CHECK(golden_screenshot.get())
-        << "A golden screenshot is required for screenshot testing";
+    // A golden screenshot is required for screenshot testing
+    CHECK(golden_screenshot.get());
     VLOG(0) << "Loaded golden screenshot";
     Result result = CompareScreenshots(golden_screenshot, current_screenshot);
     VLOG(0) << "Compared";
     LogComparisonResults(result);
     if (!result.screenshots_match && generate_artifacts_) {
       // Saving diff imag
       if (!pdiff_enabled_) {
         base::FilePath difference_image_path =
             GetImageFilePath(test_name, kDifferenceImage);
         CHECK(SaveImage(difference_image_path, result.diff_image));
@@ skipping 93 matching lines @@
 
   if (!base::PathExists(image_path)) {
     LOG(WARNING) << "Can't find a golden screenshot for this test";
     return 0;
   }
 
   int64_t golden_screenshot_size;
   base::GetFileSize(image_path, &golden_screenshot_size);
 
   if (golden_screenshot_size == -1) {
-    CHECK(false) << "Can't get golden screenshot size";
+    // Can't get golden screenshot size
+    CHECK(false);
   }
   PNGFile png_data = new base::RefCountedBytes;
   png_data->data().resize(golden_screenshot_size);
   base::ReadFile(image_path,
                  reinterpret_cast<char*>(&(png_data->data()[0])),
                  golden_screenshot_size);
 
   return png_data;
 }
 
@@ skipping 72 matching lines @@
   testing_result.screenshots_match =
       (result.result >= kPrecision &&
        result.maxRedDiff <= kMaxAllowedColorDifference &&
        result.maxGreenDiff <= kMaxAllowedColorDifference &&
        result.maxBlueDiff <= kMaxAllowedColorDifference);
 
   testing_result.similarity = result.result;
 
   testing_result.diff_image = new base::RefCountedBytes;
   testing_result.diff_image->data().resize(result.rgbDiffBitmap.getSize());
-  CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(
-      result.rgbDiffBitmap, false, &testing_result.diff_image->data()))
-      << "Could not encode difference to PNG";
+  // Could not encode difference to PNG
+  CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(result.rgbDiffBitmap, false,
+                                          &testing_result.diff_image->data()));
 
   return testing_result;
 }
 
 ScreenshotTester::Result ScreenshotTester::CompareScreenshotsPerceptually(
     SkBitmap model_bitmap,
     SkBitmap sample_bitmap) {
   SkPMetric differ;
   SkImageDiffer::BitmapsToCreate diff_parameters;
   SkImageDiffer::Result result;
 
   differ.diff(&model_bitmap, &sample_bitmap, diff_parameters, &result);
 
   ScreenshotTester::Result testing_result;
   testing_result.similarity = result.result;
   testing_result.screenshots_match =
       (result.result == SkImageDiffer::RESULT_CORRECT);
 
   return testing_result;
 }
 
 }  // namespace chromeos