base: Remove the string logging from CHECK().

ui/display/manager/chromeos/x11/native_display_delegate_x11.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 "ui/display/manager/chromeos/x11/native_display_delegate_x11.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 114 matching lines @@
   platform_event_dispatcher_.reset(new NativeDisplayEventDispatcherX11(
       helper_delegate_.get(), xrandr_event_base));
 
   if (ui::PlatformEventSource::GetInstance()) {
     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(
         platform_event_dispatcher_.get());
   }
 }
 
 void NativeDisplayDelegateX11::GrabServer() {
-  CHECK(!screen_) << "Server already grabbed";
+  // Server already grabbed
+  CHECK(!screen_);
   XGrabServer(display_);
   screen_.reset(XRRGetScreenResources(display_, window_));
   CHECK(screen_);
 }
 
 void NativeDisplayDelegateX11::UngrabServer() {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
   screen_.reset();
   XUngrabServer(display_);
   // crbug.com/366125
   XFlush(display_);
 }
 
 void NativeDisplayDelegateX11::TakeDisplayControl(
     const DisplayControlCallback& callback) {
   NOTIMPLEMENTED();
 }
@@ skipping 11 matching lines @@
   background_color_argb_ = color_argb;
 }
 
 void NativeDisplayDelegateX11::ForceDPMSOn() {
   CHECK(DPMSEnable(display_));
   CHECK(DPMSForceLevel(display_, DPMSModeOn));
 }
 
 void NativeDisplayDelegateX11::GetDisplays(
     const GetDisplaysCallback& callback) {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
 
   cached_outputs_.clear();
   std::set<RRCrtc> last_used_crtcs;
 
   InitModes();
   for (int i = 0; i < screen_->noutput; ++i) {
     RROutput output_id = screen_->outputs[i];
     XRROutputInfo* output_info =
         XRRGetOutputInfo(display_, screen_.get(), output_id);
     if (output_info->connection == RR_Connected) {
       DisplaySnapshotX11* output =
           InitDisplaySnapshot(output_id, output_info, &last_used_crtcs, i);
       cached_outputs_.push_back(output);
     }
     XRRFreeOutputInfo(output_info);
   }
 
   callback.Run(cached_outputs_.get());
 }
 
 void NativeDisplayDelegateX11::AddMode(const DisplaySnapshot& output,
                                        const DisplayMode* mode) {
-  CHECK(screen_) << "Server not grabbed";
-  CHECK(mode) << "Must add valid mode";
+  // Server not grabbed
+  CHECK(screen_);
+  // Must add valid mode
+  CHECK(mode);
 
   const DisplaySnapshotX11& x11_output =
       static_cast<const DisplaySnapshotX11&>(output);
   RRMode mode_id = static_cast<const DisplayModeX11*>(mode)->mode_id();
 
   VLOG(1) << "AddDisplayMode: output=" << x11_output.output()
           << " mode=" << mode_id;
   XRRAddOutputMode(display_, x11_output.output(), mode_id);
 }
 
 void NativeDisplayDelegateX11::Configure(const DisplaySnapshot& output,
                                          const DisplayMode* mode,
                                          const gfx::Point& origin,
                                          const ConfigureCallback& callback) {
   const DisplaySnapshotX11& x11_output =
       static_cast<const DisplaySnapshotX11&>(output);
   RRMode mode_id = None;
   if (mode)
     mode_id = static_cast<const DisplayModeX11*>(mode)->mode_id();
 
   callback.Run(ConfigureCrtc(x11_output.crtc(), mode_id, x11_output.output(),
                              origin.x(), origin.y()));
 }
 
 bool NativeDisplayDelegateX11::ConfigureCrtc(RRCrtc crtc,
                                              RRMode mode,
                                              RROutput output,
                                              int x,
                                              int y) {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
   VLOG(1) << "ConfigureCrtc: crtc=" << crtc << " mode=" << mode
           << " output=" << output << " x=" << x << " y=" << y;
   // Xrandr.h is full of lies. XRRSetCrtcConfig() is defined as returning a
   // Status, which is typically 0 for failure and 1 for success. In
   // actuality it returns a RRCONFIGSTATUS, which uses 0 for success.
   if (XRRSetCrtcConfig(display_, screen_.get(), crtc, CurrentTime, x, y, mode,
                        RR_Rotate_0, (output && mode) ? &output : NULL,
                        (output && mode) ? 1 : 0) != RRSetConfigSuccess) {
     LOG(WARNING) << "Unable to configure CRTC " << crtc << ":"
                  << " mode=" << mode << " output=" << output << " x=" << x
                  << " y=" << y;
     return false;
   }
 
   return true;
 }
 
 void NativeDisplayDelegateX11::CreateFrameBuffer(const gfx::Size& size) {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
   gfx::Size current_screen_size(
       DisplayWidth(display_, DefaultScreen(display_)),
       DisplayHeight(display_, DefaultScreen(display_)));
 
   VLOG(1) << "CreateFrameBuffer: new=" << size.ToString()
           << " current=" << current_screen_size.ToString();
 
   DestroyUnusedCrtcs();
 
   if (size == current_screen_size)
@@ skipping 23 matching lines @@
 void NativeDisplayDelegateX11::RemoveObserver(NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 display::FakeDisplayController*
 NativeDisplayDelegateX11::GetFakeDisplayController() {
   return nullptr;
 }
 
 void NativeDisplayDelegateX11::InitModes() {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
 
   modes_.clear();
 
   for (int i = 0; i < screen_->nmode; ++i) {
     const XRRModeInfo& info = screen_->modes[i];
     float refresh_rate = 0.0f;
     if (info.hTotal && info.vTotal) {
       refresh_rate =
           static_cast<float>(info.dotClock) /
           (static_cast<float>(info.hTotal) * static_cast<float>(info.vTotal));
@@ skipping 181 matching lines @@
       display_, output_id, name, XA_ATOM, 32, PropModeReplace, data, 1);
   if (err_tracker.FoundNewError()) {
     LOG(ERROR) << "XRRChangeOutputProperty failed";
     return false;
   } else {
     return true;
   }
 }
 
 void NativeDisplayDelegateX11::DestroyUnusedCrtcs() {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
 
   for (int i = 0; i < screen_->ncrtc; ++i) {
     bool in_use = false;
     for (ScopedVector<DisplaySnapshot>::const_iterator it =
              cached_outputs_.begin();
          it != cached_outputs_.end();
          ++it) {
       DisplaySnapshotX11* x11_output = static_cast<DisplaySnapshotX11*>(*it);
       if (screen_->crtcs[i] == x11_output->crtc()) {
         in_use = true;
         break;
       }
     }
 
     if (!in_use)
       ConfigureCrtc(screen_->crtcs[i], None, None, 0, 0);
   }
 }
 
 void NativeDisplayDelegateX11::UpdateCrtcsForNewFramebuffer(
     const gfx::Size& min_screen_size) {
-  CHECK(screen_) << "Server not grabbed";
+  // Server not grabbed
+  CHECK(screen_);
   // Setting the screen size will fail if any CRTC doesn't fit afterwards.
   // At the same time, turning CRTCs off and back on uses up a lot of time.
   // This function tries to be smart to avoid too many off/on cycles:
   // - We set the new modes on CRTCs, if they fit in both the old and new
   //   FBs, and park them at (0,0)
   // - We disable the CRTCs we will need but don't fit in the old FB. Those
   //   will be reenabled after the resize.
   // We don't worry about the cached state of the outputs here since we are
   // not interested in the state we are setting - we just try to get the CRTCs
   // out of the way so we can rebuild the frame buffer.
@@ skipping 129 matching lines @@
   XSetForeground(display_, gc, color.pixel);
   XSetFillStyle(display_, gc, FillSolid);
   int width = DisplayWidth(display_, DefaultScreen(display_));
   int height = DisplayHeight(display_, DefaultScreen(display_));
   XFillRectangle(display_, window_, gc, 0, 0, width, height);
   XFreeGC(display_, gc);
   XFreeColors(display_, colormap, &color.pixel, 1, 0);
 }
 
 }  // namespace ui