Fix screen flickering for Windows platform…

webrtc/modules/desktop_capture/window_capturer_win.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 85 matching lines @@
   Callback* callback_;
 
   // HWND and HDC for the currently selected window or NULL if window is not
   // selected.
   HWND window_;
 
   DesktopSize previous_size_;
 
   AeroChecker aero_checker_;
 
+  // This map is used to avoid flickering for the case when SelectWindow() calls
+  // are interleaved with Capture() calls.
+  std::map<HWND, DesktopSize> window_size_map_;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerWin);
 };
 
 WindowCapturerWin::WindowCapturerWin()
     : callback_(NULL),
       window_(NULL) {
 }
 
 WindowCapturerWin::~WindowCapturerWin() {
 }
 
 bool WindowCapturerWin::GetWindowList(WindowList* windows) {
   WindowList result;
   LPARAM param = reinterpret_cast<LPARAM>(&result);
   if (!EnumWindows(&WindowsEnumerationHandler, param))
     return false;
   windows->swap(result);
+
+  std::map<HWND, DesktopSize> new_map;
+  for (const auto& item : *windows) {
+    HWND hwnd = reinterpret_cast<HWND>(item.id);
+    new_map[hwnd] = window_size_map_[hwnd];
+  }
+  window_size_map_.swap(new_map);
+
   return true;
 }
 
 bool WindowCapturerWin::SelectWindow(WindowId id) {
   HWND window = reinterpret_cast<HWND>(id);
   if (!IsWindow(window) || !IsWindowVisible(window) || IsIconic(window))
     return false;
   window_ = window;
-  previous_size_.set(0, 0);
+  // When a window is not in the map, window_size_map_[window] will create an
+  // item with DesktopSize (0, 0).
+  previous_size_ = window_size_map_[window];
   return true;
 }
 
 bool WindowCapturerWin::BringSelectedWindowToFront() {
   if (!window_)
     return false;
 
   if (!IsWindow(window_) || !IsWindowVisible(window_) || IsIconic(window_))
     return false;
 
@@ skipping 21 matching lines @@
   }
 
   // Return a 1x1 black frame if the window is minimized or invisible, to match
   // behavior on mace. Window can be temporarily invisible during the
   // transition of full screen mode on/off.
   if (IsIconic(window_) || !IsWindowVisible(window_)) {
     BasicDesktopFrame* frame = new BasicDesktopFrame(DesktopSize(1, 1));
     memset(frame->data(), 0, frame->stride() * frame->size().height());
 
     previous_size_ = frame->size();
+    window_size_map_[window_] = previous_size_;
     callback_->OnCaptureCompleted(frame);
     return;
   }
 
   DesktopRect original_rect;
   DesktopRect cropped_rect;
   if (!GetCroppedWindowRect(window_, &cropped_rect, &original_rect)) {
     LOG(LS_WARNING) << "Failed to get window info: " << GetLastError();
     callback_->OnCaptureCompleted(NULL);
     return;
@@ skipping 46 matching lines @@
                     cropped_rect.left() - original_rect.left(),
                     cropped_rect.top() - original_rect.top(),
                     SRCCOPY);
   }
 
   SelectObject(mem_dc, previous_object);
   DeleteDC(mem_dc);
   ReleaseDC(window_, window_dc);
 
   previous_size_ = frame->size();
+  window_size_map_[window_] = previous_size_;
 
   frame->mutable_updated_region()->SetRect(
       DesktopRect::MakeSize(frame->size()));
 
   if (!result) {
     LOG(LS_ERROR) << "Both PrintWindow() and BitBlt() failed.";
     frame.reset();
   }
 
   callback_->OnCaptureCompleted(frame.release());
 }
 
 }  // namespace
 
 // static
 WindowCapturer* WindowCapturer::Create(const DesktopCaptureOptions& options) {
   return new WindowCapturerWin();
 }
 
 }  // namespace webrtc