base: Remove the string logging from CHECK().

remoting/client/plugin/pepper_video_renderer_3d.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 "remoting/client/plugin/pepper_video_renderer_3d.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 192 matching lines @@
       video_profile = PP_VIDEOPROFILE_VP9_ANY;
       break;
     default:
       NOTREACHED();
   }
 
   int32_t result = video_decoder_.Initialize(
       graphics_, video_profile, PP_HARDWAREACCELERATION_WITHFALLBACK,
       kMinimumPictureCount,
       callback_factory_.NewCallback(&PepperVideoRenderer3D::OnInitialized));
-  CHECK_EQ(result, PP_OK_COMPLETIONPENDING)
-      << "video_decoder_.Initialize() returned " << result;
+  // video_decoder_.Initialize() returned |result|
+  CHECK_EQ(result, PP_OK_COMPLETIONPENDING);
 }
 
 protocol::VideoStub* PepperVideoRenderer3D::GetVideoStub() {
   return this;
 }
 
 protocol::FrameConsumer* PepperVideoRenderer3D::GetFrameConsumer() {
   // GetFrameConsumer() is used only for WebRTC-based connections which are not
   // supported by the plugin.
   NOTREACHED();
@@ skipping 61 matching lines @@
     }
     event_handler_->OnVideoFrameDirtyRegion(dirty_region);
   }
 
   pending_frames_.push_back(std::move(frame_tracker));
   DecodeNextPacket();
 }
 
 void PepperVideoRenderer3D::OnInitialized(int32_t result) {
   // Assume that VP8 and VP9 codecs are always supported by the browser.
-  CHECK_EQ(result, PP_OK) << "VideoDecoder::Initialize() failed: " << result;
+  // VideoDecoder::Initialize() failed.
+  CHECK_EQ(result, PP_OK);
   initialization_finished_ = true;
 
   // Start decoding in case a frame was received during decoder initialization.
   DecodeNextPacket();
 }
 
 void PepperVideoRenderer3D::DecodeNextPacket() {
   if (!initialization_finished_ || decode_pending_ || pending_frames_.empty())
     return;
 
@@ skipping 140 matching lines @@
   CheckGLError();
 
   // Request PPAPI display the queued texture.
   int32_t result = graphics_.SwapBuffers(
       callback_factory_.NewCallback(&PepperVideoRenderer3D::OnPaintDone));
   CHECK_EQ(result, PP_OK_COMPLETIONPENDING);
   paint_pending_ = true;
 }
 
 void PepperVideoRenderer3D::OnPaintDone(int32_t result) {
-  CHECK_EQ(result, PP_OK) << "Graphics3D::SwapBuffers() failed";
+  // Graphics3D::SwapBuffers() failed
+  CHECK_EQ(result, PP_OK);
 
   paint_pending_ = false;
 
   for (const auto& tracker : current_picture_frames_) {
     tracker->OnRendered();
   }
   current_picture_frames_.clear();
 
   PaintIfNeeded();
 }
@@ skipping 101 matching lines @@
   int size = strlen(source);
   GLuint shader = gles2_if_->CreateShader(graphics_.pp_resource(), type);
   gles2_if_->ShaderSource(graphics_.pp_resource(), shader, 1, &source, &size);
   gles2_if_->CompileShader(graphics_.pp_resource(), shader);
   gles2_if_->AttachShader(graphics_.pp_resource(), shader_program_, shader);
   gles2_if_->DeleteShader(graphics_.pp_resource(), shader);
 }
 
 void PepperVideoRenderer3D::CheckGLError() {
   GLenum error = gles2_if_->GetError(graphics_.pp_resource());
-  CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR)) << "GL error: " << error;
+  // GL error.
+  CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR));
 }
 
 }  // namespace remoting