Fix screen capturers to initialize on the same thread on which Start() is called.

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.
  */
 
 #include "webrtc/modules/desktop_capture/screen_capturer.h"
 
 #include <string.h>
 
 #include <memory>
 #include <set>
 
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/thread_checker.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #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/include/logging.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 namespace {
 
 // A class to perform video frame capturing for Linux.
 class ScreenCapturerLinux : public ScreenCapturer,
                             public SharedXDisplay::XEventHandler {
  public:
-  ScreenCapturerLinux();
+  explicit ScreenCapturerLinux(const DesktopCaptureOptions& options);
   virtual ~ScreenCapturerLinux();
 
-  // TODO(ajwong): Do we really want this to be synchronous?
-  bool Init(const DesktopCaptureOptions& options);
-
   // DesktopCapturer interface.
   void Start(Callback* delegate) override;
   void Capture(const DesktopRegion& region) override;
 
   // ScreenCapturer interface.
   bool GetScreenList(ScreenList* screens) override;
   bool SelectScreen(ScreenId id) override;
 
  private:
   Display* display() { return options_.x_display()->display(); }
 
+  bool Initialize();
+
+  void InitXDamage();
+
   // SharedXDisplay::XEventHandler interface.
   bool HandleXEvent(const XEvent& event) override;
 
-  void InitXDamage();
-
   // Capture screen pixels to the current buffer in the queue. In the DAMAGE
   // case, the ScreenCapturerHelper already holds the list of invalid rectangles
   // from HandleXEvent(). In the non-DAMAGE case, this captures the
   // whole screen, then calculates some invalid rectangles that include any
   // differences between this and the previous capture.
   DesktopFrame* CaptureScreen();
 
   // Called when the screen configuration is changed.
   void ScreenConfigurationChanged();
 
   // Synchronize the current buffer with |last_buffer_|, by copying pixels from
   // the area of |last_invalid_rects|.
   // Note this only works on the assumption that kNumBuffers == 2, as
   // |last_invalid_rects| holds the differences from the previous buffer and
   // the one prior to that (which will then be the current buffer).
   void SynchronizeFrame();
 
   void DeinitXlib();
 
+  rtc::ThreadChecker thread_checker_;
+
   DesktopCaptureOptions options_;
 
-  Callback* callback_;
+  Callback* callback_ = nullptr;
 
   // X11 graphics context.
-  GC gc_;
-  Window root_window_;
+  GC gc_ = nullptr;
+  Window root_window_ = BadValue;
 
   // XFixes.
-  bool has_xfixes_;
-  int xfixes_event_base_;
-  int xfixes_error_base_;
+  bool has_xfixes_ = false;
+  int xfixes_event_base_ = -1;
+  int xfixes_error_base_ = -1;
 
   // XDamage information.
-  bool use_damage_;
-  Damage damage_handle_;
-  int damage_event_base_;
-  int damage_error_base_;
-  XserverRegion damage_region_;
+  bool use_damage_ = false;
+  Damage damage_handle_ = 0;
+  int damage_event_base_ = -1;
+  int damage_error_base_ = -1;
+  XserverRegion damage_region_ = 0;
 
   // Access to the X Server's pixel buffer.
   XServerPixelBuffer x_server_pixel_buffer_;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   ScreenCapturerHelper helper_;
 
   // Queue of the frames buffers.
   ScreenCaptureFrameQueue queue_;
 
   // Invalid region from the previous capture. This is used to synchronize the
   // current with the last buffer used.
   DesktopRegion last_invalid_region_;
 
   // |Differ| for use when polling for changes.
   std::unique_ptr<Differ> differ_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerLinux);
 };
 
-ScreenCapturerLinux::ScreenCapturerLinux()
-    : callback_(NULL),
-      gc_(NULL),
-      root_window_(BadValue),
-      has_xfixes_(false),
-      xfixes_event_base_(-1),
-      xfixes_error_base_(-1),
-      use_damage_(false),
-      damage_handle_(0),
-      damage_event_base_(-1),
-      damage_error_base_(-1),
-      damage_region_(0) {
-  helper_.SetLogGridSize(4);
+ScreenCapturerLinux::ScreenCapturerLinux(const DesktopCaptureOptions& options)
+    : options_(options) {
+  // ScreenCapturer can be used on a thread different from the thread on which
+  // it's created.
+  thread_checker_.DetachFromThread();
 }
 
 ScreenCapturerLinux::~ScreenCapturerLinux() {
   options_.x_display()->RemoveEventHandler(ConfigureNotify, this);
   if (use_damage_) {
     options_.x_display()->RemoveEventHandler(
         damage_event_base_ + XDamageNotify, this);
   }
   DeinitXlib();
 }
 
-bool ScreenCapturerLinux::Init(const DesktopCaptureOptions& options) {
-  options_ = options;
+bool ScreenCapturerLinux::Initialize() {
+  helper_.SetLogGridSize(4);
 
   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) {
@@ skipping 34 matching lines @@
     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(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(!callback_);
   RTC_DCHECK(callback);
 
   callback_ = callback;
+
+  if (!Initialize()) {
+    callback_->OnInitializationFailed();
+  }
 }
 
 void ScreenCapturerLinux::Capture(const DesktopRegion& region) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
   TickTime capture_start_time = TickTime::Now();
 
   queue_.MoveToNextFrame();
 
   // Process XEvents for XDamage and cursor shape tracking.
   options_.x_display()->ProcessPendingXEvents();
 
   // ProcessPendingXEvents() may call ScreenConfigurationChanged() which
   // reinitializes |x_server_pixel_buffer_|. Check if the pixel buffer is still
   // in a good shape.
@@ skipping 25 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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(jiayl): implement screen selection.
   return true;
 }
 
 bool ScreenCapturerLinux::HandleXEvent(const XEvent& event) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
   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;
     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();
-  assert(x_server_pixel_buffer_.window_size().equals(frame->size()));
+  RTC_DCHECK(x_server_pixel_buffer_.window_size().equals(frame->size()));
 
   // Pass the screen size to the helper, so it can clip the invalid region if it
   // expands that region to a grid.
   helper_.set_size_most_recent(frame->size());
 
   // In the DAMAGE case, ensure the frame is up-to-date with the previous frame
   // if any.  If there isn't a previous frame, that means a screen-resolution
   // change occurred, and |invalid_rects| will be updated to include the whole
   // screen.
   if (use_damage_ && queue_.previous_frame())
@@ skipping 106 matching lines @@
   }
 }
 
 }  // namespace
 
 // static
 ScreenCapturer* ScreenCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.x_display())
     return NULL;
 
-  std::unique_ptr<ScreenCapturerLinux> capturer(new ScreenCapturerLinux());
-  if (!capturer->Init(options))
-    capturer.reset();
-  return capturer.release();
+  return new ScreenCapturerLinux(options);
 }
 
 }  // namespace webrtc