Merge ScreenCapturerWinDirectx::frames_ and contexts_

webrtc/modules/desktop_capture/win/dxgi_frame.cc

+/*
+ *  Copyright (c) 2017 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/win/dxgi_frame.h"
+
+#include <utility>
+
+#include "webrtc/base/checks.h"
+#include "webrtc/modules/desktop_capture/desktop_frame.h"
+#include "webrtc/modules/desktop_capture/win/dxgi_duplicator_controller.h"
+
+namespace webrtc {
+
+DxgiFrame::Context::Context() = default;
+
+DxgiFrame::Context::~Context() {
+  DxgiDuplicatorController::Instance()->Unregister(this);
+}
+
+void DxgiFrame::Context::Reset() {
+  identity = 0;
+}
+
+DxgiFrame::DxgiFrame(SharedMemoryFactory* factory)
+    : factory_(factory) {}
+
+DxgiFrame::~DxgiFrame() = default;
+
+bool DxgiFrame::Prepare(DesktopSize size, DesktopCapturer::SourceId source_id) {
+  if (source_id != source_id_) {

[Sergey Ulanov, 2017/04/18 23:39:09]

Do we need to reuse the same frame for multiple source_id's? Shouldn't the
capturer create new set of frames when source is changed?

[Hzj_jie, 2017/04/19 04:35:54]

I think that's a little bit less optimized. If the screen resolution does not
change, we do not need to create a new frame at all. (line 45)

[Sergey Ulanov, 2017/04/19 23:29:27]

Frame allocation is relatively cheap and also source_id normally doesn't change.
Allocating a new frame when source_id changes would make this code simpler and
less error-prone.

[Hzj_jie, 2017/04/20 01:07:28]

That's not really the meaning of this function. Here, the context_ will be reset
if ScreenCapturerWinDirectx selected another source, but not because of the
reinitialization. So the |source_id| must be changed.
The DesktopFrame will only be recreated once the resolution of the capturing
target changed, but no matter whether the |source_id| is changed. So this
function takes two parameters, each one has its own meaning and triggers an
action with a clear reason.

+    // Once the source has been changed, the entire source should be copied.
+    source_id_ = source_id;
+    context_.Reset();
+  }
+
+  if (resolution_change_detector_.IsChanged(size)) {
+    // Once the output size changed, recreate the SharedDesktopFrame.
+    frame_.reset();
+    resolution_change_detector_.Reset();
+  }
+
+  if (!frame_) {
+    std::unique_ptr<DesktopFrame> frame;
+    if (factory_) {
+      frame = SharedMemoryDesktopFrame::Create(size, factory_);
+    } else {
+      frame.reset(new BasicDesktopFrame(size));
+    }
+    if (!frame) {
+      return false;
+    }
+
+    frame_ = SharedDesktopFrame::Wrap(std::move(frame));
+  }
+
+  return !!frame_;
+}
+
+SharedDesktopFrame* DxgiFrame::frame() const {
+  RTC_DCHECK(frame_);
+  return frame_.get();
+}
+
+DxgiFrame::Context* DxgiFrame::context() {
+  RTC_DCHECK(frame_);
+  return &context_;
+}
+
+}  // namespace webrtc