Repaint windows on screen unlock.

ui/views/win/hwnd_message_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
+#include <wtsapi32.h>
+#pragma comment(lib, "wtsapi32.lib")
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/touch/touch_enabled.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/base/win/shell.h"
 #include "ui/base/win/touch_input.h"
 #include "ui/events/event.h"
@@ skipping 289 matching lines @@
 }
 
 void AddScrollStylesToWindow(HWND window) {
   if (::IsWindow(window)) {
     long current_style = ::GetWindowLong(window, GWL_STYLE);
     ::SetWindowLong(window, GWL_STYLE,
                     current_style | WS_VSCROLL | WS_HSCROLL);
   }
 }
 
+bool IsWorkstationLocked() {
+  bool is_locked = true;
+  HDESK input_desk = ::OpenInputDesktop(0, 0, GENERIC_READ);

[cpu_(ooo_6.6-7.5), 2014/01/19 20:52:45]

Opening the input desktop still has me confused. You want to know if your
process is attached to the desktop that has input right?

I see my previous idea does not work on XP, so you can use
http://www.experts-exchange.com/Programming/System/Windows__Programming/Q_235...

+  if (input_desk) {
+    wchar_t name[256] = {0};
+    DWORD needed = 0;
+    if (::GetUserObjectInformation(
+            input_desk, UOI_NAME, name, sizeof(name), &needed)) {
+      is_locked = lstrcmpi(name, L"default") != 0;
+    }
+    ::CloseDesktop(input_desk);
+  }
+  return is_locked;
+}
+
 }  // namespace
 
 // A scoping class that prevents a window from being able to redraw in response
 // to invalidations that may occur within it for the lifetime of the object.
 //
 // Why would we want such a thing? Well, it turns out Windows has some
 // "unorthodox" behavior when it comes to painting its non-client areas.
 // Occasionally, Windows will paint portions of the default non-client area
 // right over the top of the custom frame. This is not simply fixed by handling
 // WM_NCPAINT/WM_PAINT, with some investigation it turns out that this
@@ skipping 952 matching lines @@
   POINT position = {wr.left, wr.top};
   HDC dib_dc = skia::BeginPlatformPaint(layered_window_contents_->sk_canvas());
   POINT zero = {0, 0};
   BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA};
   UpdateLayeredWindow(hwnd(), NULL, &position, &size, dib_dc, &zero,
                       RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA);
   invalid_rect_.SetRect(0, 0, 0, 0);
   skia::EndPlatformPaint(layered_window_contents_->sk_canvas());
 }
 
+void HWNDMessageHandler::ForceRedrawWindow(int attempts) {
+  if (IsWorkstationLocked()) {
+    // Presents will continue to fail as long as the input desktop is
+    // unavailable.
+    if (--attempts <= 0)
+      return;
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&HWNDMessageHandler::ForceRedrawWindow,
+                   weak_factory_.GetWeakPtr(),
+                   attempts),
+        base::TimeDelta::FromMilliseconds(500));
+    return;
+  }
+  InvalidateRect(hwnd(), NULL, FALSE);
+}
+
 // Message handlers ------------------------------------------------------------
 
 void HWNDMessageHandler::OnActivateApp(BOOL active, DWORD thread_id) {
   if (delegate_->IsWidgetWindow() && !active &&
       thread_id != GetCurrentThreadId()) {
     delegate_->HandleAppDeactivated();
     // Also update the native frame if it is rendering the non-client area.
     if (!remove_standard_frame_ && !delegate_->IsUsingCustomFrame())
       DefWindowProcWithRedrawLock(WM_NCACTIVATE, FALSE, 0);
   }
@@ skipping 79 matching lines @@
 #if !defined(USE_AURA)
   // We need to add ourselves as a message loop observer so that we can repaint
   // aggressively if the contents of our window become invalid. Unfortunately
   // WM_PAINT messages are starved and we get flickery redrawing when resizing
   // if we do not do this.
   base::MessageLoopForUI::current()->AddObserver(this);
 #endif
 
   delegate_->HandleCreate();
 
+  WTSRegisterSessionNotification(hwnd(), NOTIFY_FOR_THIS_SESSION);
+
   // TODO(beng): move more of NWW::OnCreate here.
   return 0;
 }
 
 void HWNDMessageHandler::OnDestroy() {
+  WTSUnRegisterSessionNotification(hwnd());
   delegate_->HandleDestroying();
 }
 
 void HWNDMessageHandler::OnDisplayChange(UINT bits_per_pixel,
                                          const CSize& screen_size) {
   delegate_->HandleDisplayChange();
 }
 
 LRESULT HWNDMessageHandler::OnDwmCompositionChanged(UINT msg,
                                                     WPARAM w_param,
@@ skipping 641 matching lines @@
 
 LRESULT HWNDMessageHandler::OnScrollMessage(UINT message,
                                             WPARAM w_param,
                                             LPARAM l_param) {
   MSG msg = { hwnd(), message, w_param, l_param, GetMessageTime() };
   ui::ScrollEvent event(msg);
   delegate_->HandleScrollEvent(event);
   return 0;
 }
 
+void HWNDMessageHandler::OnSessionChange(WPARAM status_code,
+                                         PWTSSESSION_NOTIFICATION session_id) {
+  // Direct3D presents are ignored while the screen is locked, so force the
+  // window to be redrawn on unlock.
+  if (status_code == WTS_SESSION_UNLOCK)
+    ForceRedrawWindow(10);
+
+  SetMsgHandled(FALSE);
+}
+
 LRESULT HWNDMessageHandler::OnSetCursor(UINT message,
                                         WPARAM w_param,
                                         LPARAM l_param) {
   // Reimplement the necessary default behavior here. Calling DefWindowProc can
   // trigger weird non-client painting for non-glass windows with custom frames.
   // Using a ScopedRedrawLock to prevent caption rendering artifacts may allow
   // content behind this window to incorrectly paint in front of this window.
   // Invalidating the window to paint over either set of artifacts is not ideal.
   wchar_t* cursor = IDC_ARROW;
   switch (LOWORD(l_param)) {
@@ skipping 292 matching lines @@
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::HandleTouchEvents(const TouchEvents& touch_events) {
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
   for (size_t i = 0; i < touch_events.size() && ref; ++i)
     delegate_->HandleTouchEvent(touch_events[i]);
 }
 
 }  // namespace views