| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome_frame/chrome_frame_helper_util.h" | |
| 6 #include "chrome_frame/chrome_tab.h" | |
| 7 | |
| 8 #include <shlwapi.h> | |
| 9 #include <stdio.h> | |
| 10 | |
| 11 namespace { | |
| 12 | |
| 13 const wchar_t kGetBrowserMessage[] = L"GetAutomationObject"; | |
| 14 | |
| 15 const wchar_t kBHORegistrationPathFmt[] = | |
| 16 L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer" | |
| 17 L"\\Browser Helper Objects\\%s"; | |
| 18 const wchar_t kChromeFrameClientKey[] = | |
| 19 L"Software\\Google\\Update\\Clients\\" | |
| 20 L"{8BA986DA-5100-405E-AA35-86F34A02ACBF}"; | |
| 21 const wchar_t kGoogleUpdateVersionValue[] = L"pv"; | |
| 22 | |
| 23 } // namespace | |
| 24 | |
| 25 bool UtilIsWebBrowserWindow(HWND window_to_check) { | |
| 26 bool is_browser_window = false; | |
| 27 | |
| 28 if (!IsWindow(window_to_check)) { | |
| 29 return is_browser_window; | |
| 30 } | |
| 31 | |
| 32 static wchar_t* known_ie_window_classes[] = { | |
| 33 L"IEFrame", | |
| 34 L"TabWindowClass" | |
| 35 }; | |
| 36 | |
| 37 for (int i = 0; i < ARRAYSIZE(known_ie_window_classes); i++) { | |
| 38 if (IsWindowOfClass(window_to_check, known_ie_window_classes[i])) { | |
| 39 is_browser_window = true; | |
| 40 break; | |
| 41 } | |
| 42 } | |
| 43 | |
| 44 return is_browser_window; | |
| 45 } | |
| 46 | |
| 47 HRESULT UtilGetWebBrowserObjectFromWindow(HWND window, | |
| 48 REFIID iid, | |
| 49 void** web_browser_object) { | |
| 50 if (NULL == web_browser_object) { | |
| 51 return E_POINTER; | |
| 52 } | |
| 53 | |
| 54 // Check whether this window is really a web browser window. | |
| 55 if (UtilIsWebBrowserWindow(window)) { | |
| 56 // IWebBroswer2 interface pointer can be retrieved from the browser | |
| 57 // window by simply sending a registered message "GetAutomationObject" | |
| 58 // Note that since we are sending a message to parent window make sure that | |
| 59 // it is in the same thread. | |
| 60 if (GetWindowThreadProcessId(window, NULL) != GetCurrentThreadId()) { | |
| 61 return E_UNEXPECTED; | |
| 62 } | |
| 63 | |
| 64 static const ULONG get_browser_message = | |
| 65 RegisterWindowMessageW(kGetBrowserMessage); | |
| 66 | |
| 67 *web_browser_object = | |
| 68 reinterpret_cast<void*>(SendMessage(window, | |
| 69 get_browser_message, | |
| 70 reinterpret_cast<WPARAM>(&iid), | |
| 71 NULL)); | |
| 72 if (NULL != *web_browser_object) { | |
| 73 return S_OK; | |
| 74 } | |
| 75 } else { | |
| 76 return E_INVALIDARG; | |
| 77 } | |
| 78 return E_NOINTERFACE; | |
| 79 } | |
| 80 | |
| 81 bool IsWindowOfClass(HWND window_to_check, const wchar_t* window_class) { | |
| 82 bool window_matches = false; | |
| 83 const int buf_size = MAX_PATH; | |
| 84 wchar_t buffer[buf_size] = {0}; | |
| 85 DWORD size = GetClassNameW(window_to_check, buffer, buf_size); | |
| 86 // If the window name is any longer than this, it isn't the one we want. | |
| 87 if (size < (buf_size - 1)) { | |
| 88 if (!lstrcmpiW(window_class, buffer)) { | |
| 89 window_matches = true; | |
| 90 } | |
| 91 } | |
| 92 return window_matches; | |
| 93 } | |
| 94 | |
| 95 bool IsNamedWindow(HWND window, const wchar_t* window_name) { | |
| 96 bool window_matches = false; | |
| 97 const int buf_size = MAX_PATH; | |
| 98 wchar_t buffer[buf_size] = {0}; | |
| 99 DWORD size = GetWindowText(window, buffer, buf_size); | |
| 100 if (size < (buf_size - 1)) { | |
| 101 if (!lstrcmpiW(window_name, buffer)) { | |
| 102 window_matches = true; | |
| 103 } | |
| 104 } | |
| 105 return window_matches; | |
| 106 } | |
| 107 | |
| 108 bool IsNamedProcess(const wchar_t* process_name) { | |
| 109 wchar_t file_path[2048] = {0}; | |
| 110 GetModuleFileName(NULL, file_path, 2047); | |
| 111 wchar_t* file_name = PathFindFileName(file_path); | |
| 112 return (0 == lstrcmpiW(file_name, process_name)); | |
| 113 } | |
| 114 | |
| 115 namespace { | |
| 116 struct FindWindowParams { | |
| 117 HWND parent_; | |
| 118 const wchar_t* class_name_; | |
| 119 const wchar_t* window_name_; | |
| 120 HWND window_found_; | |
| 121 DWORD thread_id_; | |
| 122 DWORD process_id_; | |
| 123 FindWindowParams(HWND parent, | |
| 124 const wchar_t* class_name, | |
| 125 const wchar_t* window_name, | |
| 126 DWORD thread_id, | |
| 127 DWORD process_id) | |
| 128 : parent_(parent), | |
| 129 class_name_(class_name), | |
| 130 window_name_(window_name), | |
| 131 window_found_(NULL), | |
| 132 thread_id_(thread_id), | |
| 133 process_id_(process_id) { | |
| 134 } | |
| 135 }; | |
| 136 | |
| 137 // Checks a window against a set of parameters defined in params. If the | |
| 138 // window matches, fills in params->window_found_ with the HWND of the window | |
| 139 // and returns true. Returns false otherwise. | |
| 140 bool WindowMatches(HWND window, FindWindowParams* params) { | |
| 141 bool found = false; | |
| 142 DWORD process_id = 0; | |
| 143 DWORD thread_id = GetWindowThreadProcessId(window, &process_id); | |
| 144 | |
| 145 // First check that the PID and TID match if we're interested. | |
| 146 if (params->process_id_ == 0 || params->process_id_ == process_id) { | |
| 147 if (params->thread_id_ == 0 || params->thread_id_ == thread_id) { | |
| 148 // Then check that we match on class and window names, again only if | |
| 149 // we're interested. | |
| 150 if ((params->class_name_ == NULL || | |
| 151 IsWindowOfClass(window, params->class_name_)) && | |
| 152 (params->window_name_ == NULL) || | |
| 153 IsNamedWindow(window, params->window_name_)) { | |
| 154 found = true; | |
| 155 params->window_found_ = window; | |
| 156 } | |
| 157 } | |
| 158 } | |
| 159 return found; | |
| 160 } | |
| 161 | |
| 162 } // namespace | |
| 163 | |
| 164 BOOL CALLBACK WndEnumProc(HWND window, LPARAM lparam) { | |
| 165 FindWindowParams* params = reinterpret_cast<FindWindowParams *>(lparam); | |
| 166 if (!params) { | |
| 167 return FALSE; | |
| 168 } | |
| 169 | |
| 170 if (WindowMatches(window, params)) { | |
| 171 // We found a match on a top level window. Return false to stop enumerating. | |
| 172 return FALSE; | |
| 173 } else { | |
| 174 // If criteria not satisfied, let us try child windows. | |
| 175 HWND child_window = RecurseFindWindow(window, | |
| 176 params->class_name_, | |
| 177 params->window_name_, | |
| 178 params->thread_id_, | |
| 179 params->process_id_); | |
| 180 if (child_window != NULL) { | |
| 181 // We found the window we are looking for. | |
| 182 params->window_found_ = child_window; | |
| 183 return FALSE; | |
| 184 } | |
| 185 return TRUE; | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 HWND RecurseFindWindow(HWND parent, | |
| 190 const wchar_t* class_name, | |
| 191 const wchar_t* window_name, | |
| 192 DWORD thread_id_to_match, | |
| 193 DWORD process_id_to_match) { | |
| 194 if ((class_name == NULL) && (window_name == NULL)) { | |
| 195 return NULL; | |
| 196 } | |
| 197 FindWindowParams params(parent, class_name, window_name, | |
| 198 thread_id_to_match, process_id_to_match); | |
| 199 EnumChildWindows(parent, WndEnumProc, reinterpret_cast<LPARAM>(¶ms)); | |
| 200 return params.window_found_; | |
| 201 } | |
| 202 | |
| 203 // TODO(robertshield): This is stolen shamelessly from mini_installer.cc. | |
| 204 // Refactor this before (more) bad things happen. | |
| 205 LONG ReadValue(HKEY key, | |
| 206 const wchar_t* value_name, | |
| 207 size_t value_size, | |
| 208 wchar_t* value) { | |
| 209 DWORD type; | |
| 210 DWORD byte_length = static_cast<DWORD>(value_size * sizeof(wchar_t)); | |
| 211 LONG result = ::RegQueryValueEx(key, value_name, NULL, &type, | |
| 212 reinterpret_cast<BYTE*>(value), | |
| 213 &byte_length); | |
| 214 if (result == ERROR_SUCCESS) { | |
| 215 if (type != REG_SZ) { | |
| 216 result = ERROR_NOT_SUPPORTED; | |
| 217 } else if (byte_length == 0) { | |
| 218 *value = L'\0'; | |
| 219 } else if (value[byte_length/sizeof(wchar_t) - 1] != L'\0') { | |
| 220 if ((byte_length / sizeof(wchar_t)) < value_size) | |
| 221 value[byte_length / sizeof(wchar_t)] = L'\0'; | |
| 222 else | |
| 223 result = ERROR_MORE_DATA; | |
| 224 } | |
| 225 } | |
| 226 return result; | |
| 227 } | |
| 228 | |
| 229 bool IsBHOLoadingPolicyRegistered() { | |
| 230 wchar_t bho_clsid_as_string[MAX_PATH] = {0}; | |
| 231 int count = StringFromGUID2(CLSID_ChromeFrameBHO, bho_clsid_as_string, | |
| 232 ARRAYSIZE(bho_clsid_as_string)); | |
| 233 | |
| 234 bool bho_registered = false; | |
| 235 if (count > 0) { | |
| 236 wchar_t reg_path_buffer[MAX_PATH] = {0}; | |
| 237 int path_count = _snwprintf(reg_path_buffer, | |
| 238 MAX_PATH - 1, | |
| 239 kBHORegistrationPathFmt, | |
| 240 bho_clsid_as_string); | |
| 241 | |
| 242 if (path_count > 0) { | |
| 243 HKEY reg_handle = NULL; | |
| 244 LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, | |
| 245 reg_path_buffer, | |
| 246 0, | |
| 247 KEY_QUERY_VALUE, | |
| 248 ®_handle); | |
| 249 if (result == ERROR_SUCCESS) { | |
| 250 RegCloseKey(reg_handle); | |
| 251 bho_registered = true; | |
| 252 } | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 return bho_registered; | |
| 257 } | |
| 258 | |
| 259 bool IsSystemLevelChromeFrameInstalled() { | |
| 260 bool system_level_installed = false; | |
| 261 HKEY reg_handle = NULL; | |
| 262 LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, | |
| 263 kChromeFrameClientKey, | |
| 264 0, | |
| 265 KEY_QUERY_VALUE, | |
| 266 ®_handle); | |
| 267 if (result == ERROR_SUCCESS) { | |
| 268 wchar_t version_buffer[MAX_PATH] = {0}; | |
| 269 result = ReadValue(reg_handle, | |
| 270 kGoogleUpdateVersionValue, | |
| 271 MAX_PATH, | |
| 272 version_buffer); | |
| 273 if (result == ERROR_SUCCESS && version_buffer[0] != L'\0') { | |
| 274 system_level_installed = true; | |
| 275 } | |
| 276 RegCloseKey(reg_handle); | |
| 277 } | |
| 278 | |
| 279 return system_level_installed; | |
| 280 } | |
| 281 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src