windowCapture: return 1x1 frame to minimized winodw on Linux.

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.
  */
 
@@ skipping 93 matching lines @@
   // that has WM_STATE property set to NormalState.
   // See http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.3.1 .
   ::Window GetApplicationWindow(::Window window);
 
   // Returns true if the |window| is a desktop element.
   bool IsDesktopElement(::Window window);
 
   // Returns window title for the specified X |window|.
   bool GetWindowTitle(::Window window, std::string* title);
 
+  // Return WM_STATE property of the |window|.
+  int32_t GetWindowState(::Window window);
+
   Callback* callback_ = nullptr;
 
   rtc::scoped_refptr<SharedXDisplay> x_display_;
 
   Atom wm_state_atom_;
   Atom window_type_atom_;
   Atom normal_window_type_atom_;
   bool has_composite_extension_ = false;
 
   ::Window selected_window_ = 0;
@@ skipping 155 matching lines @@
 
   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;
   }
 
+  if (GetWindowState(selected_window_) == IconicState) {
+    // Window is in minimized. Return a 1x1 frame as same as OSX/Win does.
+    std::unique_ptr<DesktopFrame> frame(
+        new BasicDesktopFrame(DesktopSize(1, 1)));
+    callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
+    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;
   }
 
@@ skipping 11 matching lines @@
       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;
-
+  int32_t state = GetWindowState(window);
   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;
@@ skipping 74 matching lines @@
       }
       if (list)
         XFreeStringList(list);
     }
     if (window_name.value)
       XFree(window_name.value);
   }
   return result;
 }
 
+int32_t WindowCapturerLinux::GetWindowState(::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.
+  return window_state.is_valid() ? *window_state.data() : WithdrawnState;
+}
+
 }  // 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