Remove differ from ScreenCapturer implementations

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 <utility>
 
 #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/constructormagic.h"
 #include "webrtc/base/timeutils.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_differ_wrapper.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
+// is necessary.
 class ScreenCapturerLinux : public ScreenCapturer,
                             public SharedXDisplay::XEventHandler {
  public:
   ScreenCapturerLinux();
   virtual ~ScreenCapturerLinux();
 
   // TODO(ajwong): Do we really want this to be synchronous?
   bool Init(const DesktopCaptureOptions& options);
 
   // DesktopCapturer interface.
@@ skipping 58 matching lines @@
   // recently captured screen.
   ScreenCapturerHelper helper_;
 
   // Queue of the frames buffers.
   ScreenCaptureFrameQueue<SharedDesktopFrame> 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() {
   helper_.SetLogGridSize(4);
 }
 
 ScreenCapturerLinux::~ScreenCapturerLinux() {
   options_.x_display()->RemoveEventHandler(ConfigureNotify, this);
   if (use_damage_) {
@@ skipping 114 matching lines @@
 
   // If the current frame is from an older generation then allocate a new one.
   // Note that we can't reallocate other buffers at this point, since the caller
   // may still be reading from them.
   if (!queue_.current_frame()) {
     queue_.ReplaceCurrentFrame(
         SharedDesktopFrame::Wrap(std::unique_ptr<DesktopFrame>(
             new BasicDesktopFrame(x_server_pixel_buffer_.window_size()))));
   }
 
-  // Refresh the Differ helper used by CaptureFrame(), if needed.
-  DesktopFrame* frame = queue_.current_frame();
-  if (!use_damage_ &&
-      (!differ_ || (differ_->width() != frame->size().width()) ||
-       (differ_->height() != frame->size().height()) ||
-       (differ_->bytes_per_row() != frame->stride()))) {
-    differ_.reset(new Differ(frame->size().width(), frame->size().height(),
-                             DesktopFrame::kBytesPerPixel, frame->stride()));
-  }
-
   std::unique_ptr<DesktopFrame> result = CaptureScreen();
   last_invalid_region_ = result->updated_region();
   result->set_capture_time_ms((rtc::TimeNanos() - capture_start_time_nanos) /
                               rtc::kNumNanosecsPerMillisec);
   callback_->OnCaptureResult(Result::SUCCESS, std::move(result));
 }
 
 bool ScreenCapturerLinux::GetScreenList(ScreenList* screens) {
   RTC_DCHECK(screens->size() == 0);
   // TODO(jiayl): implement screen enumeration.
@@ skipping 66 matching lines @@
 
     for (DesktopRegion::Iterator it(*updated_region);
          !it.IsAtEnd(); it.Advance()) {
       x_server_pixel_buffer_.CaptureRect(it.rect(), frame.get());
     }
   } else {
     // Doing full-screen polling, or this is the first capture after a
     // screen-resolution change.  In either case, need a full-screen capture.
     DesktopRect screen_rect = DesktopRect::MakeSize(frame->size());
     x_server_pixel_buffer_.CaptureRect(screen_rect, frame.get());
-
-    if (queue_.previous_frame()) {
-      // Full-screen polling, so calculate the invalid rects here, based on the
-      // changed pixels between current and previous buffers.
-      RTC_DCHECK(differ_);
-      RTC_DCHECK(queue_.previous_frame()->data());
-      differ_->CalcDirtyRegion(queue_.previous_frame()->data(),
-                               frame->data(), updated_region);
-    } else {
-      // No previous buffer, so always invalidate the whole screen, whether
-      // or not DAMAGE is being used.  DAMAGE doesn't necessarily send a
-      // full-screen notification after a screen-resolution change, so
-      // this is done here.
-      updated_region->SetRect(screen_rect);
-    }
+    updated_region->SetRect(screen_rect);
   }
 
   return std::move(frame);
 }
 
 void ScreenCapturerLinux::ScreenConfigurationChanged() {
   // Make sure the frame buffers will be reallocated.
   queue_.Reset();
 
   helper_.ClearInvalidRegion();
@@ skipping 57 matching lines @@
   }
 
   if (options.detect_updated_region()) {
     capturer.reset(new ScreenCapturerDifferWrapper(std::move(capturer)));
   }
 
   return capturer.release();
 }
 
 }  // namespace webrtc