Add RTC_ prefix to (D)CHECKs and related macros.

webrtc/modules/desktop_capture/screen_capturer_x11.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 12 matching lines @@
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/differ.h"
 #include "webrtc/modules/desktop_capture/screen_capture_frame_queue.h"
 #include "webrtc/modules/desktop_capture/screen_capturer_helper.h"
 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/tick_util.h"
 
 // TODO(sergeyu): Move this to a header where it can be shared.
 #if defined(NDEBUG)
-#define DCHECK(condition) (void)(condition)
+#define RTC_DCHECK(condition) (void)(condition)
 #else  // NDEBUG
-#define DCHECK(condition) if (!(condition)) {abort();}
+#define RTC_DCHECK(condition) \
+  if (!(condition)) {         \
+    abort();                  \
+  }
 #endif
 
 namespace webrtc {
 
 namespace {
 
 // A class to perform video frame capturing for Linux.
 class ScreenCapturerLinux : public ScreenCapturer,
                             public SharedXDisplay::XEventHandler {
  public:
@@ skipping 180 matching lines @@
   }
 
   options_.x_display()->AddEventHandler(
       damage_event_base_ + XDamageNotify, this);
 
   use_damage_ = true;
   LOG(LS_INFO) << "Using XDamage extension.";
 }
 
 void ScreenCapturerLinux::Start(Callback* callback) {
-  DCHECK(!callback_);
-  DCHECK(callback);
+  RTC_DCHECK(!callback_);
+  RTC_DCHECK(callback);
 
   callback_ = callback;
 }
 
 void ScreenCapturerLinux::Capture(const DesktopRegion& region) {
   TickTime capture_start_time = TickTime::Now();
 
   queue_.MoveToNextFrame();
 
   // Process XEvents for XDamage and cursor shape tracking.
@@ skipping 30 matching lines @@
   }
 
   DesktopFrame* result = CaptureScreen();
   last_invalid_region_ = result->updated_region();
   result->set_capture_time_ms(
       (TickTime::Now() - capture_start_time).Milliseconds());
   callback_->OnCaptureCompleted(result);
 }
 
 bool ScreenCapturerLinux::GetScreenList(ScreenList* screens) {
-  DCHECK(screens->size() == 0);
+  RTC_DCHECK(screens->size() == 0);
   // TODO(jiayl): implement screen enumeration.
   Screen default_screen;
   default_screen.id = 0;
   screens->push_back(default_screen);
   return true;
 }
 
 bool ScreenCapturerLinux::SelectScreen(ScreenId id) {
   // TODO(jiayl): implement screen selection.
   return true;
 }
 
 bool ScreenCapturerLinux::HandleXEvent(const XEvent& event) {
   if (use_damage_ && (event.type == damage_event_base_ + XDamageNotify)) {
     const XDamageNotifyEvent* damage_event =
         reinterpret_cast<const XDamageNotifyEvent*>(&event);
     if (damage_event->damage != damage_handle_)
       return false;
-    DCHECK(damage_event->level == XDamageReportNonEmpty);
+    RTC_DCHECK(damage_event->level == XDamageReportNonEmpty);
     return true;
   } else if (event.type == ConfigureNotify) {
     ScreenConfigurationChanged();
     return true;
   }
   return false;
 }
 
 DesktopFrame* ScreenCapturerLinux::CaptureScreen() {
   DesktopFrame* frame = queue_.current_frame()->Share();
@@ skipping 42 matching lines @@
     }
   } else {
     // Doing full-screen polling, or this is the first capture after a
     // screen-resolution change.  In either case, need a full-screen capture.
     DesktopRect screen_rect = DesktopRect::MakeSize(frame->size());
     x_server_pixel_buffer_.CaptureRect(screen_rect, frame);
 
     if (queue_.previous_frame()) {
       // Full-screen polling, so calculate the invalid rects here, based on the
       // changed pixels between current and previous buffers.
-      DCHECK(differ_.get() != NULL);
-      DCHECK(queue_.previous_frame()->data());
+      RTC_DCHECK(differ_.get() != NULL);
+      RTC_DCHECK(queue_.previous_frame()->data());
       differ_->CalcDirtyRegion(queue_.previous_frame()->data(),
                                frame->data(), updated_region);
     } else {
       // No previous buffer, so always invalidate the whole screen, whether
       // or not DAMAGE is being used.  DAMAGE doesn't necessarily send a
       // full-screen notification after a screen-resolution change, so
       // this is done here.
       updated_region->SetRect(screen_rect);
     }
   }
@@ skipping 14 matching lines @@
 
 void ScreenCapturerLinux::SynchronizeFrame() {
   // Synchronize the current buffer with the previous one since we do not
   // capture the entire desktop. Note that encoder may be reading from the
   // previous buffer at this time so thread access complaints are false
   // positives.
 
   // TODO(hclam): We can reduce the amount of copying here by subtracting
   // |capturer_helper_|s region from |last_invalid_region_|.
   // http://crbug.com/92354
-  DCHECK(queue_.previous_frame());
+  RTC_DCHECK(queue_.previous_frame());
 
   DesktopFrame* current = queue_.current_frame();
   DesktopFrame* last = queue_.previous_frame();
-  DCHECK(current != last);
+  RTC_DCHECK(current != last);
   for (DesktopRegion::Iterator it(last_invalid_region_);
        !it.IsAtEnd(); it.Advance()) {
     current->CopyPixelsFrom(*last, it.rect().top_left(), it.rect());
   }
 }
 
 void ScreenCapturerLinux::DeinitXlib() {
   if (gc_) {
     XFreeGC(display(), gc_);
     gc_ = NULL;
@@ skipping 21 matching lines @@
   if (!options.x_display())
     return NULL;
 
   rtc::scoped_ptr<ScreenCapturerLinux> capturer(new ScreenCapturerLinux());
   if (!capturer->Init(options))
     capturer.reset();
   return capturer.release();
 }
 
 }  // namespace webrtc