OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/host/win/message_window.h" | 5 #include "base/win/message_window.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/process_util.h" | 8 #include "base/process_util.h" |
| 9 #include "base/strings/string16.h" |
9 #include "base/strings/stringprintf.h" | 10 #include "base/strings/stringprintf.h" |
10 #include "base/strings/utf_string_conversions.h" | |
11 #include "base/win/wrapped_window_proc.h" | 11 #include "base/win/wrapped_window_proc.h" |
12 | 12 |
13 const char kClassNameFormat[] = "Chromoting_MessageWindow_%p"; | 13 const wchar_t kClassNameFormat[] = L"Chrome_MessageWindow_%p"; |
14 | 14 |
15 namespace remoting { | 15 namespace base { |
16 namespace win { | 16 namespace win { |
17 | 17 |
18 MessageWindow::MessageWindow() | 18 MessageWindow::MessageWindow() |
19 : atom_(0), | 19 : atom_(0), |
20 instance_(NULL), | |
21 window_(NULL) { | |
22 class_name_ = base::StringPrintf(kClassNameFormat, this); | |
23 instance_ = base::GetModuleFromAddress(static_cast<WNDPROC>( | |
24 &base::win::WrappedWindowProc<WindowProc>)); | |
25 } | |
26 | |
27 MessageWindow::MessageWindow(const std::string& class_name, HINSTANCE instance) | |
28 : atom_(0), | |
29 class_name_(class_name), | |
30 instance_(instance), | |
31 window_(NULL) { | 20 window_(NULL) { |
32 } | 21 } |
33 | 22 |
34 MessageWindow::~MessageWindow() { | 23 MessageWindow::~MessageWindow() { |
35 DCHECK(CalledOnValidThread()); | 24 DCHECK(CalledOnValidThread()); |
36 | 25 |
37 if (window_ != NULL) { | 26 if (window_ != NULL) { |
38 DestroyWindow(window_); | 27 BOOL result = DestroyWindow(window_); |
39 window_ = NULL; | 28 DCHECK(result); |
40 } | 29 } |
41 | 30 |
42 if (atom_ != 0) { | 31 if (atom_ != 0) { |
43 UnregisterClass(MAKEINTATOM(atom_), instance_); | 32 BOOL result = UnregisterClass( |
44 atom_ = 0; | 33 MAKEINTATOM(atom_), |
| 34 base::GetModuleFromAddress(&MessageWindow::WindowProc)); |
| 35 DCHECK(result); |
45 } | 36 } |
46 } | 37 } |
47 | 38 |
48 bool MessageWindow::Create(Delegate* delegate) { | 39 bool MessageWindow::Create(Delegate* delegate, const wchar_t* window_name) { |
49 DCHECK(CalledOnValidThread()); | 40 DCHECK(CalledOnValidThread()); |
50 DCHECK(!atom_); | 41 DCHECK(!atom_); |
51 DCHECK(!window_); | 42 DCHECK(!window_); |
52 | 43 |
53 // Register a separate window class for each instance of |MessageWindow|. | 44 // Register a separate window class for each instance of |MessageWindow|. |
54 string16 class_name = UTF8ToUTF16(class_name_); | 45 string16 class_name = base::StringPrintf(kClassNameFormat, this); |
| 46 HINSTANCE instance = base::GetModuleFromAddress(&MessageWindow::WindowProc); |
| 47 |
55 WNDCLASSEX window_class; | 48 WNDCLASSEX window_class; |
56 window_class.cbSize = sizeof(window_class); | 49 window_class.cbSize = sizeof(window_class); |
57 window_class.style = 0; | 50 window_class.style = 0; |
58 window_class.lpfnWndProc = &base::win::WrappedWindowProc<WindowProc>; | 51 window_class.lpfnWndProc = &base::win::WrappedWindowProc<WindowProc>; |
59 window_class.cbClsExtra = 0; | 52 window_class.cbClsExtra = 0; |
60 window_class.cbWndExtra = 0; | 53 window_class.cbWndExtra = 0; |
61 window_class.hInstance = instance_; | 54 window_class.hInstance = instance; |
62 window_class.hIcon = NULL; | 55 window_class.hIcon = NULL; |
63 window_class.hCursor = NULL; | 56 window_class.hCursor = NULL; |
64 window_class.hbrBackground = NULL; | 57 window_class.hbrBackground = NULL; |
65 window_class.lpszMenuName = NULL; | 58 window_class.lpszMenuName = NULL; |
66 window_class.lpszClassName = class_name.c_str(); | 59 window_class.lpszClassName = class_name.c_str(); |
67 window_class.hIconSm = NULL; | 60 window_class.hIconSm = NULL; |
68 atom_ = RegisterClassEx(&window_class); | 61 atom_ = RegisterClassEx(&window_class); |
69 if (atom_ == 0) { | 62 if (atom_ == 0) { |
70 LOG_GETLASTERROR(ERROR) | 63 LOG_GETLASTERROR(ERROR) |
71 << "Failed to register the window class '" << class_name_ << "'"; | 64 << "Failed to register the window class for a message-only window"; |
72 return false; | 65 return false; |
73 } | 66 } |
74 | 67 |
75 window_ = CreateWindow(MAKEINTATOM(atom_), 0, 0, 0, 0, 0, 0, HWND_MESSAGE, 0, | 68 window_ = CreateWindow(MAKEINTATOM(atom_), window_name, 0, 0, 0, 0, 0, |
76 instance_, delegate); | 69 HWND_MESSAGE, 0, instance, delegate); |
77 if (!window_) { | 70 if (!window_) { |
78 LOG_GETLASTERROR(ERROR) << "Failed to create a message-only window"; | 71 LOG_GETLASTERROR(ERROR) << "Failed to create a message-only window"; |
79 return false; | 72 return false; |
80 } | 73 } |
81 | 74 |
82 return true; | 75 return true; |
83 } | 76 } |
84 | 77 |
85 // static | 78 // static |
86 LRESULT CALLBACK MessageWindow::WindowProc(HWND hwnd, | 79 LRESULT CALLBACK MessageWindow::WindowProc(HWND hwnd, |
87 UINT message, | 80 UINT message, |
88 WPARAM wparam, | 81 WPARAM wparam, |
89 LPARAM lparam) { | 82 LPARAM lparam) { |
90 Delegate* delegate = NULL; | 83 Delegate* delegate = reinterpret_cast<Delegate*>( |
| 84 GetWindowLongPtr(hwnd, GWLP_USERDATA)); |
91 | 85 |
92 // Set up the delegate before handling WM_CREATE. | 86 switch (message) { |
93 if (message == WM_CREATE) { | 87 // Set up the delegate before handling WM_CREATE. |
94 CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lparam); | 88 case WM_CREATE: { |
95 delegate = reinterpret_cast<Delegate*>(cs->lpCreateParams); | 89 CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lparam); |
| 90 delegate = reinterpret_cast<Delegate*>(cs->lpCreateParams); |
96 | 91 |
97 // Store pointer to the delegate to the window's user data. | 92 // Store pointer to the delegate to the window's user data. |
98 SetLastError(ERROR_SUCCESS); | 93 SetLastError(ERROR_SUCCESS); |
99 LONG_PTR result = SetWindowLongPtr( | 94 LONG_PTR result = SetWindowLongPtr( |
100 hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(delegate)); | 95 hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(delegate)); |
101 CHECK(result != 0 || GetLastError() == ERROR_SUCCESS); | 96 CHECK(result != 0 || GetLastError() == ERROR_SUCCESS); |
102 } else { | 97 break; |
103 delegate = reinterpret_cast<Delegate*>(GetWindowLongPtr(hwnd, | 98 } |
104 GWLP_USERDATA)); | 99 |
| 100 // Clear the pointer to stop calling the delegate once WM_DESTROY is |
| 101 // received. |
| 102 case WM_DESTROY: { |
| 103 SetLastError(ERROR_SUCCESS); |
| 104 LONG_PTR result = SetWindowLongPtr(hwnd, GWLP_USERDATA, NULL); |
| 105 CHECK(result != 0 || GetLastError() == ERROR_SUCCESS); |
| 106 break; |
| 107 } |
105 } | 108 } |
106 | 109 |
107 // Handle the message. | 110 // Handle the message. |
108 if (delegate) { | 111 if (delegate) { |
109 LRESULT message_result; | 112 LRESULT message_result; |
110 if (delegate->HandleMessage(hwnd, message, wparam, lparam, &message_result)) | 113 if (delegate->HandleMessage(hwnd, message, wparam, lparam, &message_result)) |
111 return message_result; | 114 return message_result; |
112 } | 115 } |
113 | 116 |
114 return DefWindowProc(hwnd, message, wparam, lparam); | 117 return DefWindowProc(hwnd, message, wparam, lparam); |
115 } | 118 } |
116 | 119 |
117 } // namespace win | 120 } // namespace win |
118 } // namespace remoting | 121 } // namespace base |
OLD | NEW |