Moved code implementing message-only windows to a dedicated class (Windows only).

remoting/host/win/host_service.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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/host_service.h"
 
 #include <sddl.h>
 #include <windows.h>
 #include <wtsapi32.h>
 
 #include "base/base_paths.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_com_initializer.h"
-#include "base/win/wrapped_window_proc.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/base/stoppable.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/logging.h"
 #include "remoting/host/win/security_descriptor.h"
 
 #if defined(REMOTING_MULTI_PROCESS)
 #include "remoting/host/daemon_process.h"
 #endif  // defined(REMOTING_MULTI_PROCESS)
 
 #include "remoting/host/win/core_resource.h"
 #include "remoting/host/win/wts_terminal_observer.h"
 
 #if !defined(REMOTING_MULTI_PROCESS)
 #include "remoting/host/win/wts_console_session_process_driver.h"
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
 namespace remoting {
 
 namespace {
 
 const char kIoThreadName[] = "I/O thread";
 
-// A window class for the session change notifications window.
-const wchar_t kSessionNotificationWindowClass[] =
-  L"Chromoting_SessionNotificationWindow";
-
 // Command line switches:
 
 // "--console" runs the service interactively for debugging purposes.
 const char kConsoleSwitchName[] = "console";
 
 // Concatenates ACE type, permissions and sid given as SDDL strings into an ACE
 // definition in SDDL form.
 #define SDDL_ACE(type, permissions, sid) \
     L"(" type L";;" permissions L";;;" sid L")"
 
@@ skipping 330 matching lines @@
     return result;
 
   // Subscribe to Ctrl-C and other console events.
   if (!SetConsoleCtrlHandler(&HostService::ConsoleControlHandler, TRUE)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to set console control handler";
     return result;
   }
 
   // Create a window for receiving session change notifications.
-  HWND window = NULL;
-  WNDCLASSEX window_class;
-  base::win::InitializeWindowClass(
-      kSessionNotificationWindowClass,
-      &base::win::WrappedWindowProc<SessionChangeNotificationProc>,
-      0, 0, 0, NULL, NULL, NULL, NULL, NULL,
-      &window_class);
-  HINSTANCE instance = window_class.hInstance;
-  ATOM atom = RegisterClassExW(&window_class);
-  if (atom == 0) {
+  win::MessageWindow window;
+  if (!window.Create(this)) {
     LOG_GETLASTERROR(ERROR)
-        << "Failed to register the window class '"
-        << kSessionNotificationWindowClass << "'";
-    goto cleanup;
-  }
-
-  window = CreateWindowW(MAKEINTATOM(atom), 0, 0, 0, 0, 0, 0, HWND_MESSAGE, 0,
-                         instance, 0);
-  if (window == NULL) {
-    LOG_GETLASTERROR(ERROR)
-        << "Failed to creat the session notificationwindow";
+        << "Failed to create the session notification window";
     goto cleanup;
   }
 
   // Subscribe to session change notifications.
-  if (WTSRegisterSessionNotification(window,
+  if (WTSRegisterSessionNotification(window.hwnd(),
                                      NOTIFY_FOR_ALL_SESSIONS) != FALSE) {
     CreateLauncher(scoped_refptr<AutoThreadTaskRunner>(
         new AutoThreadTaskRunner(main_task_runner_,
                                  run_loop.QuitClosure())));
 
     // Run the service.
     run_loop.Run();
 
     // Release the control handler.
     stopped_event_.Signal();
 
-    WTSUnRegisterSessionNotification(window);
+    WTSUnRegisterSessionNotification(window.hwnd());
     result = kSuccessExitCode;
   }
 
 cleanup:
-  if (window != NULL) {
-    DestroyWindow(window);
-  }
-
-  if (atom != 0) {
-    UnregisterClass(MAKEINTATOM(atom), instance);
-  }
-
   // Unsubscribe from console events. Ignore the exit code. There is nothing
   // we can do about it now and the program is about to exit anyway. Even if
   // it crashes nothing is going to be broken because of it.
   SetConsoleCtrlHandler(&HostService::ConsoleControlHandler, FALSE);
 
   return result;
 }
 
+bool HostService::HandleMessage(
+    HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, LRESULT* result) {
+  if (message == WM_WTSSESSION_CHANGE) {
+    OnSessionChange(wparam, lparam);
+    *result = 0;
+    return true;
+  }
+
+  return false;
+}
+
 // static
 BOOL WINAPI HostService::ConsoleControlHandler(DWORD event) {
   HostService* self = HostService::GetInstance();
   switch (event) {
     case CTRL_C_EVENT:
     case CTRL_BREAK_EVENT:
     case CTRL_CLOSE_EVENT:
     case CTRL_LOGOFF_EVENT:
     case CTRL_SHUTDOWN_EVENT:
       self->main_task_runner_->PostTask(FROM_HERE, base::Bind(
@@ skipping 39 matching lines @@
   HostService* self = HostService::GetInstance();
 
   // Run the service.
   self->RunAsServiceImpl();
 
   // Release the control handler and notify the main thread that it can exit
   // now.
   self->stopped_event_.Signal();
 }
 
-// static
-LRESULT CALLBACK HostService::SessionChangeNotificationProc(HWND hwnd,
-                                                            UINT message,
-                                                            WPARAM wparam,
-                                                            LPARAM lparam) {
-  switch (message) {
-    case WM_WTSSESSION_CHANGE: {
-      HostService* self = HostService::GetInstance();
-      self->OnSessionChange(wparam, lparam);
-      return 0;
-    }
-
-    default:
-      return DefWindowProc(hwnd, message, wparam, lparam);
-  }
-}
-
 int DaemonProcessMain() {
   HostService* service = HostService::GetInstance();
   if (!service->InitWithCommandLine(CommandLine::ForCurrentProcess())) {
     return kUsageExitCode;
   }
 
   return service->Run();
 }
 
 } // namespace remoting