Delete all log messages depending on system_wrappers.

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 11 matching lines @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.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/shared_desktop_frame.h"
 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
-#include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 namespace {
 
 // A class to perform video frame capturing for Linux.
 //
 // If XDamage is used, this class sets DesktopFrame::updated_region() according
 // to the areas reported by XDamage. Otherwise this class does not detect
 // DesktopFrame::updated_region(), the field is always set to the entire frame
 // rectangle. ScreenCapturerDifferWrapper should be used if that functionality
@@ skipping 88 matching lines @@
         damage_event_base_ + XDamageNotify, this);
   }
   DeinitXlib();
 }
 
 bool ScreenCapturerLinux::Init(const DesktopCaptureOptions& options) {
   options_ = options;
 
   root_window_ = RootWindow(display(), DefaultScreen(display()));
   if (root_window_ == BadValue) {
-    LOG(LS_ERROR) << "Unable to get the root window";
     DeinitXlib();
     return false;
   }
 
   gc_ = XCreateGC(display(), root_window_, 0, NULL);
   if (gc_ == NULL) {
-    LOG(LS_ERROR) << "Unable to get graphics context";
     DeinitXlib();
     return false;
   }
 
   options_.x_display()->AddEventHandler(ConfigureNotify, this);
 
   // Check for XFixes extension. This is required for cursor shape
   // notifications, and for our use of XDamage.
   if (XFixesQueryExtension(display(), &xfixes_event_base_,
                            &xfixes_error_base_)) {
     has_xfixes_ = true;
   } else {
-    LOG(LS_INFO) << "X server does not support XFixes.";
   }
 
   // Register for changes to the dimensions of the root window.
   XSelectInput(display(), root_window_, StructureNotifyMask);
 
   if (!x_server_pixel_buffer_.Init(display(), DefaultRootWindow(display()))) {
-    LOG(LS_ERROR) << "Failed to initialize pixel buffer.";
     return false;
   }
 
   if (options_.use_update_notifications()) {
     InitXDamage();
   }
 
   return true;
 }
 
 void ScreenCapturerLinux::InitXDamage() {
   // Our use of XDamage requires XFixes.
   if (!has_xfixes_) {
     return;
   }
 
   // Check for XDamage extension.
   if (!XDamageQueryExtension(display(), &damage_event_base_,
                              &damage_error_base_)) {
-    LOG(LS_INFO) << "X server does not support XDamage.";
     return;
   }
 
   // TODO(lambroslambrou): Disable DAMAGE in situations where it is known
   // to fail, such as when Desktop Effects are enabled, with graphics
   // drivers (nVidia, ATI) that fail to report DAMAGE notifications
   // properly.
 
   // Request notifications every time the screen becomes damaged.
   damage_handle_ = XDamageCreate(display(), root_window_,
                                  XDamageReportNonEmpty);
   if (!damage_handle_) {
-    LOG(LS_ERROR) << "Unable to initialize XDamage.";
     return;
   }
 
   // Create an XFixes server-side region to collate damage into.
   damage_region_ = XFixesCreateRegion(display(), 0, 0);
   if (!damage_region_) {
     XDamageDestroy(display(), damage_handle_);
-    LOG(LS_ERROR) << "Unable to create XFixes region.";
     return;
   }
 
   options_.x_display()->AddEventHandler(
       damage_event_base_ + XDamageNotify, this);
 
   use_damage_ = true;
-  LOG(LS_INFO) << "Using XDamage extension.";
 }
 
 void ScreenCapturerLinux::Start(Callback* callback) {
   RTC_DCHECK(!callback_);
   RTC_DCHECK(callback);
 
   callback_ = callback;
 }
 
 void ScreenCapturerLinux::CaptureFrame() {
@@ skipping 119 matching lines @@
 
   return std::move(frame);
 }
 
 void ScreenCapturerLinux::ScreenConfigurationChanged() {
   // Make sure the frame buffers will be reallocated.
   queue_.Reset();
 
   helper_.ClearInvalidRegion();
   if (!x_server_pixel_buffer_.Init(display(), DefaultRootWindow(display()))) {
-    LOG(LS_ERROR) << "Failed to initialize pixel buffer after screen "
-        "configuration change.";
   }
 }
 
 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
@@ skipping 41 matching lines @@
 
   std::unique_ptr<ScreenCapturerLinux> capturer(new ScreenCapturerLinux());
   if (!capturer.get()->Init(options)) {
     return nullptr;
   }
 
   return std::move(capturer);
 }
 
 }  // namespace webrtc