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

webrtc/modules/desktop_capture/screen_capturer_mac.mm

 /*
  *  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 <stddef.h>
 
 #include <memory>
 #include <set>
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/macutils.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/desktop_geometry.h"
 #include "webrtc/modules/desktop_capture/desktop_region.h"
 #include "webrtc/modules/desktop_capture/mac/desktop_configuration.h"
 #include "webrtc/modules/desktop_capture/mac/desktop_configuration_monitor.h"
 #include "webrtc/modules/desktop_capture/mac/scoped_pixel_buffer_object.h"
 #include "webrtc/modules/desktop_capture/screen_capture_frame_queue.h"
 #include "webrtc/modules/desktop_capture/screen_capturer_helper.h"
 #include "webrtc/system_wrappers/include/logging.h"
@@ skipping 145 matching lines @@
       window_bounds, window_list, kCGWindowImageDefault);
 }
 
 // A class to perform video frame capturing for mac.
 class ScreenCapturerMac : public ScreenCapturer {
  public:
   explicit ScreenCapturerMac(
       rtc::scoped_refptr<DesktopConfigurationMonitor> desktop_config_monitor);
   virtual ~ScreenCapturerMac();
 
-  bool Init();
-
   // Overridden from ScreenCapturer:
   void Start(Callback* callback) override;
   void Capture(const DesktopRegion& region) override;
   void SetExcludedWindow(WindowId window) override;
   bool GetScreenList(ScreenList* screens) override;
   bool SelectScreen(ScreenId id) override;
 
  private:
+  bool Initialize();
+
   void GlBlitFast(const DesktopFrame& frame,
                   const DesktopRegion& region);
   void GlBlitSlow(const DesktopFrame& frame);
   void CgBlitPreLion(const DesktopFrame& frame,
                      const DesktopRegion& region);
   // Returns false if the selected screen is no longer valid.
   bool CgBlitPostLion(const DesktopFrame& frame,
                       const DesktopRegion& region);
 
   // Called when the screen configuration is changed.
@@ skipping 10 matching lines @@
                                     const CGRect *rect_array,
                                     void *user_parameter);
   static void ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
                                        size_t count,
                                        const CGRect *rect_array,
                                        void *user_parameter);
   void ReleaseBuffers();
 
   DesktopFrame* CreateFrame();
 
-  Callback* callback_;
+  rtc::ThreadChecker thread_checker_;
 
-  CGLContextObj cgl_context_;
+  Callback* callback_ = nullptr;
+
+  CGLContextObj cgl_context_ = nullptr;
   ScopedPixelBufferObject pixel_buffer_object_;
 
   // Queue of the frames buffers.
   ScreenCaptureFrameQueue queue_;
 
   // Current display configuration.
   MacDesktopConfiguration desktop_config_;
 
   // Currently selected display, or 0 if the full desktop is selected. On OS X
   // 10.6 and before, this is always 0.
-  CGDirectDisplayID current_display_;
+  CGDirectDisplayID current_display_ = 0;
 
   // The physical pixel bounds of the current screen.
   DesktopRect screen_pixel_bounds_;
 
   // The dip to physical pixel scale of the current screen.
-  float dip_to_pixel_scale_;
+  float dip_to_pixel_scale_ = 1.0f;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   ScreenCapturerHelper helper_;
 
   // Contains an invalid region from the previous capture.
   DesktopRegion last_invalid_region_;
 
   // Monitoring display reconfiguration.
   rtc::scoped_refptr<DesktopConfigurationMonitor> desktop_config_monitor_;
 
   // Power management assertion to prevent the screen from sleeping.
-  IOPMAssertionID power_assertion_id_display_;
+  IOPMAssertionID power_assertion_id_display_ = kIOPMNullAssertionID;
 
   // Power management assertion to indicate that the user is active.
-  IOPMAssertionID power_assertion_id_user_;
+  IOPMAssertionID power_assertion_id_user_ = kIOPMNullAssertionID;
 
   // Dynamically link to deprecated APIs for Mac OS X 10.6 support.
-  void* app_services_library_;
-  CGDisplayBaseAddressFunc cg_display_base_address_;
-  CGDisplayBytesPerRowFunc cg_display_bytes_per_row_;
-  CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_;
-  void* opengl_library_;
+  void* app_services_library_ = nullptr;
+  CGDisplayBaseAddressFunc cg_display_base_address_ = nullptr;
+  CGDisplayBytesPerRowFunc cg_display_bytes_per_row_ = nullptr;
+  CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_ = nullptr;
+  void* opengl_library_ = nullptr;
   CGLSetFullScreenFunc cgl_set_full_screen_;
 
-  CGWindowID excluded_window_;
+  CGWindowID excluded_window_ = 0;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerMac);
 };
 
 // DesktopFrame wrapper that flips wrapped frame upside down by inverting
 // stride.
 class InvertedDesktopFrame : public DesktopFrame {
  public:
   // Takes ownership of |frame|.
   InvertedDesktopFrame(DesktopFrame* frame)
       : DesktopFrame(
             frame->size(), -frame->stride(),
             frame->data() + (frame->size().height() - 1) * frame->stride(),
             frame->shared_memory()),
         original_frame_(frame) {
     set_dpi(frame->dpi());
     set_capture_time_ms(frame->capture_time_ms());
     mutable_updated_region()->Swap(frame->mutable_updated_region());
   }
   virtual ~InvertedDesktopFrame() {}
 
  private:
   std::unique_ptr<DesktopFrame> original_frame_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(InvertedDesktopFrame);
 };
 
 ScreenCapturerMac::ScreenCapturerMac(
-    rtc::scoped_refptr<DesktopConfigurationMonitor> desktop_config_monitor)
-    : callback_(NULL),
-      cgl_context_(NULL),
-      current_display_(0),
-      dip_to_pixel_scale_(1.0f),
-      desktop_config_monitor_(desktop_config_monitor),
-      power_assertion_id_display_(kIOPMNullAssertionID),
-      power_assertion_id_user_(kIOPMNullAssertionID),
-      app_services_library_(NULL),
-      cg_display_base_address_(NULL),
-      cg_display_bytes_per_row_(NULL),
-      cg_display_bits_per_pixel_(NULL),
-      opengl_library_(NULL),
-      cgl_set_full_screen_(NULL),
-      excluded_window_(0) {
+    rtc::scoped_refptr<DesktopConfigurationMonitor> desktop_config_monitor) {
+  // ScreenCapturer can be used on a thread different from the thread on which
+  // it's created.
+  thread_checker_.DetachFromThread();

[Jamie, 2016/04/06 01:17:31]

Doesn't this belong in Initialize() in that case? I don't think calling
DetachFromThread in a ctor can have any effect, right?

[Sergey Ulanov, 2016/04/06 21:39:41]

ThreadChecker automatically attaches itself in the constructor, see
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...
. Here we want to make sure that the thread checker is in the detached state
after the constructor returns.
In the host we want to create the capturer on the network thread and use it on
the capturer thread. When Start() is called the thread checker gets attached to
the current thread, which ensures that all other methods are executed on the
same thread. Only the constructor is allowed to run on a different thread,
that's why we need to detach it here.

[Jamie, 2016/04/07 00:38:51]

Thanks for clarifying. I was confused by the equivalent class in Chromium (which
has the same semantics, but it's less obvious from reading the code).

 }
 
 ScreenCapturerMac::~ScreenCapturerMac() {
   if (power_assertion_id_display_ != kIOPMNullAssertionID) {
     IOPMAssertionRelease(power_assertion_id_display_);
     power_assertion_id_display_ = kIOPMNullAssertionID;
   }
   if (power_assertion_id_user_ != kIOPMNullAssertionID) {
     IOPMAssertionRelease(power_assertion_id_user_);
     power_assertion_id_user_ = kIOPMNullAssertionID;
   }
 
   ReleaseBuffers();
   UnregisterRefreshAndMoveHandlers();
   dlclose(app_services_library_);
   dlclose(opengl_library_);
 }
 
-bool ScreenCapturerMac::Init() {
+bool ScreenCapturerMac::Initialize() {
   if (!RegisterRefreshAndMoveHandlers()) {
     return false;
   }
   desktop_config_monitor_->Lock();
   desktop_config_ = desktop_config_monitor_->desktop_configuration();
   desktop_config_monitor_->Unlock();
   ScreenConfigurationChanged();
   return true;
 }
 
 void ScreenCapturerMac::ReleaseBuffers() {
   if (cgl_context_) {
     pixel_buffer_object_.Release();
     CGLDestroyContext(cgl_context_);
     cgl_context_ = NULL;
   }
   // The buffers might be in use by the encoder, so don't delete them here.
   // Instead, mark them as "needs update"; next time the buffers are used by
   // the capturer, they will be recreated if necessary.
   queue_.Reset();
 }
 
 void ScreenCapturerMac::Start(Callback* callback) {
-  assert(!callback_);
-  assert(callback);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(!callback_);
+  RTC_DCHECK(callback);
 
   callback_ = callback;
 
+  if (!Initialize()) {
+    callback_->OnInitializationFailed();
+    return;
+  }
+
   // Create power management assertions to wake the display and prevent it from
   // going to sleep on user idle.
   // TODO(jamiewalch): Use IOPMAssertionDeclareUserActivity on 10.7.3 and above
   //                   instead of the following two assertions.
   IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep,
                               kIOPMAssertionLevelOn,
                               CFSTR("Chrome Remote Desktop connection active"),
                               &power_assertion_id_display_);
   // This assertion ensures that the display is woken up if it  already asleep
   // (as used by Apple Remote Desktop).
   IOPMAssertionCreateWithName(CFSTR("UserIsActive"),
                               kIOPMAssertionLevelOn,
                               CFSTR("Chrome Remote Desktop connection active"),
                               &power_assertion_id_user_);
 }
 
 void ScreenCapturerMac::Capture(const DesktopRegion& region_to_capture) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
   TickTime capture_start_time = TickTime::Now();
 
   queue_.MoveToNextFrame();
 
   desktop_config_monitor_->Lock();
   MacDesktopConfiguration new_config =
       desktop_config_monitor_->desktop_configuration();
   if (!desktop_config_.Equals(new_config)) {
     desktop_config_ = new_config;
     // If the display configuraiton has changed then refresh capturer data
@@ skipping 48 matching lines @@
   // Signal that we are done capturing data from the display framebuffer,
   // and accessing display structures.
   desktop_config_monitor_->Unlock();
 
   new_frame->set_capture_time_ms(
       (TickTime::Now() - capture_start_time).Milliseconds());
   callback_->OnCaptureCompleted(new_frame);
 }
 
 void ScreenCapturerMac::SetExcludedWindow(WindowId window) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   excluded_window_ = window;
 }
 
 bool ScreenCapturerMac::GetScreenList(ScreenList* screens) {
-  assert(screens->size() == 0);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(screens->size() == 0);
+
   if (rtc::GetOSVersionName() < rtc::kMacOSLion) {
     // Single monitor cast is not supported on pre OS X 10.7.
     Screen screen;
     screen.id = kFullDesktopScreenId;
     screens->push_back(screen);
     return true;
   }
 
   for (MacDisplayConfigurations::iterator it = desktop_config_.displays.begin();
        it != desktop_config_.displays.end(); ++it) {
     Screen screen;
     screen.id = static_cast<ScreenId>(it->id);
     screens->push_back(screen);
   }
   return true;
 }
 
 bool ScreenCapturerMac::SelectScreen(ScreenId id) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
   if (rtc::GetOSVersionName() < rtc::kMacOSLion) {
     // Ignore the screen selection on unsupported OS.
     assert(!current_display_);
     return id == kFullDesktopScreenId;
   }
 
   if (id == kFullDesktopScreenId) {
     current_display_ = 0;
   } else {
     const MacDisplayConfiguration* config =
@@ skipping 488 matching lines @@
   return frame.release();
 }
 
 }  // namespace
 
 // static
 ScreenCapturer* ScreenCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.configuration_monitor())
     return NULL;
 
-  std::unique_ptr<ScreenCapturerMac> capturer(
-      new ScreenCapturerMac(options.configuration_monitor()));
-  if (!capturer->Init())
-    capturer.reset();
-  return capturer.release();
+  return new ScreenCapturerMac(options.configuration_monitor());
 }
 
 }  // namespace webrtc