Delete all log messages depending on system_wrappers.

webrtc/modules/desktop_capture/window_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.
  */
 
 #include <assert.h>
 #include <string.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/Xcomposite.h>
 #include <X11/extensions/Xrender.h>
 #include <X11/Xutil.h>
 
 #include <algorithm>
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/scoped_ref_ptr.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/x11/shared_x_display.h"
 #include "webrtc/modules/desktop_capture/x11/x_error_trap.h"
 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
-#include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 
 namespace {
 
 // Convenience wrapper for XGetWindowProperty() results.
 template <class PropertyType>
 class XWindowProperty {
  public:
   XWindowProperty(Display* display, Window window, Atom property) {
@@ skipping 95 matching lines @@
   normal_window_type_atom_ = XInternAtom(
       display(), "_NET_WM_WINDOW_TYPE_NORMAL", True);
 
   int event_base, error_base, major_version, minor_version;
   if (XCompositeQueryExtension(display(), &event_base, &error_base) &&
       XCompositeQueryVersion(display(), &major_version, &minor_version) &&
       // XCompositeNameWindowPixmap() requires version 0.2
       (major_version > 0 || minor_version >= 2)) {
     has_composite_extension_ = true;
   } else {
-    LOG(LS_INFO) << "Xcomposite extension not available or too old.";
   }
 
   x_display_->AddEventHandler(ConfigureNotify, this);
 }
 
 WindowCapturerLinux::~WindowCapturerLinux() {
   x_display_->RemoveEventHandler(ConfigureNotify, this);
 }
 
 bool WindowCapturerLinux::GetSourceList(SourceList* sources) {
   SourceList result;
 
   XErrorTrap error_trap(display());
 
   int num_screens = XScreenCount(display());
   for (int screen = 0; screen < num_screens; ++screen) {
     ::Window root_window = XRootWindow(display(), screen);
     ::Window parent;
     ::Window *children;
     unsigned int num_children;
     int status = XQueryTree(display(), root_window, &root_window, &parent,
                             &children, &num_children);
     if (status == 0) {
-      LOG(LS_ERROR) << "Failed to query for child windows for screen "
-                    << screen;
       continue;
     }
 
     for (unsigned int i = 0; i < num_children; ++i) {
       // Iterate in reverse order to return windows from front to back.
       ::Window app_window =
           GetApplicationWindow(children[num_children - 1 - i]);
       if (app_window && !IsDesktopElement(app_window)) {
         Source w;
         w.id = app_window;
@@ skipping 37 matching lines @@
     return false;
 
   unsigned int num_children;
   ::Window* children;
   ::Window parent;
   ::Window root;
   // Find the root window to pass event to.
   int status = XQueryTree(
       display(), selected_window_, &root, &parent, &children, &num_children);
   if (status == 0) {
-    LOG(LS_ERROR) << "Failed to query for the root window.";
     return false;
   }
 
   if (children)
     XFree(children);
 
   XRaiseWindow(display(), selected_window_);
 
   // Some window managers (e.g., metacity in GNOME) consider it illegal to
   // raise a window without also giving it input focus with
@@ skipping 25 matching lines @@
 
 void WindowCapturerLinux::Start(Callback* callback) {
   assert(!callback_);
   assert(callback);
 
   callback_ = callback;
 }
 
 void WindowCapturerLinux::CaptureFrame() {
   if (!x_server_pixel_buffer_.IsWindowValid()) {
-    LOG(LS_INFO) << "The window is no longer valid.";
     callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   x_display_->ProcessPendingXEvents();
 
   if (!has_composite_extension_) {
     // Without the Xcomposite extension we capture when the whole window is
     // visible on screen and not covered by any other window. This is not
     // something we want so instead, just bail out.
-    LOG(LS_INFO) << "No Xcomposite extension detected.";
     callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   std::unique_ptr<DesktopFrame> frame(
       new BasicDesktopFrame(x_server_pixel_buffer_.window_size()));
 
   x_server_pixel_buffer_.Synchronize();
   if (!x_server_pixel_buffer_.CaptureRect(DesktopRect::MakeSize(frame->size()),
                                           frame.get())) {
     callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     return;
   }
 
   frame->mutable_updated_region()->SetRect(
       DesktopRect::MakeSize(frame->size()));
 
   callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
 }
 
 bool WindowCapturerLinux::HandleXEvent(const XEvent& event) {
   if (event.type == ConfigureNotify) {
     XConfigureEvent xce = event.xconfigure;
     if (!DesktopSize(xce.width, xce.height).equals(
             x_server_pixel_buffer_.window_size())) {
       if (!x_server_pixel_buffer_.Init(display(), selected_window_)) {
-        LOG(LS_ERROR) << "Failed to initialize pixel buffer after resizing.";
       }
       return true;
     }
   }
   return false;
 }
 
 ::Window WindowCapturerLinux::GetApplicationWindow(::Window window) {
   // Get WM_STATE property of the window.
   XWindowProperty<uint32_t> window_state(display(), window, wm_state_atom_);
 
   // WM_STATE is considered to be set to WithdrawnState when it missing.
   int32_t state = window_state.is_valid() ?
       *window_state.data() : WithdrawnState;
 
   if (state == NormalState) {
     // Window has WM_STATE==NormalState. Return it.
     return window;
   } else if (state == IconicState) {
     // Window is in minimized. Skip it.
     return 0;
   }
 
   // If the window is in WithdrawnState then look at all of its children.
   ::Window root, parent;
   ::Window *children;
   unsigned int num_children;
   if (!XQueryTree(display(), window, &root, &parent, &children,
                   &num_children)) {
-    LOG(LS_ERROR) << "Failed to query for child windows although window"
-                  << "does not have a valid WM_STATE.";
     return 0;
   }
   ::Window app_window = 0;
   for (unsigned int i = 0; i < num_children; ++i) {
     app_window = GetApplicationWindow(children[i]);
     if (app_window)
       break;
   }
 
   if (children)
@@ skipping 43 matching lines @@
   window_name.value = nullptr;
   if (window) {
     status = XGetWMName(display(), window, &window_name);
     if (status && window_name.value && window_name.nitems) {
       int cnt;
       char** list = nullptr;
       status = Xutf8TextPropertyToTextList(display(), &window_name, &list,
                                            &cnt);
       if (status >= Success && cnt && *list) {
         if (cnt > 1) {
-          LOG(LS_INFO) << "Window has " << cnt
-                       << " text properties, only using the first one.";
         }
         *title = *list;
         result = true;
       }
       if (list)
         XFreeStringList(list);
     }
     if (window_name.value)
       XFree(window_name.value);
   }
   return result;
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<DesktopCapturer> DesktopCapturer::CreateRawWindowCapturer(
     const DesktopCaptureOptions& options) {
   if (!options.x_display())
     return nullptr;
   return std::unique_ptr<DesktopCapturer>(new WindowCapturerLinux(options));
 }
 
 }  // namespace webrtc