// Copyright (c) 2011 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 "chrome_frame/chrome_frame_helper_util.h"
#include "chrome_frame/chrome_tab.h"
#include <shlwapi.h>
#include <stdio.h>
namespace {
const wchar_t kGetBrowserMessage[] = L"GetAutomationObject";
const wchar_t kBHORegistrationPathFmt[] =
L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer"
L"\\Browser Helper Objects\\%s";
const wchar_t kChromeFrameClientKey[] =
L"Software\\Google\\Update\\Clients\\"
L"{8BA986DA-5100-405E-AA35-86F34A02ACBF}";
const wchar_t kGoogleUpdateVersionValue[] = L"pv";
} // namespace
bool UtilIsWebBrowserWindow(HWND window_to_check) {
bool is_browser_window = false;
if (!IsWindow(window_to_check)) {
return is_browser_window;
}
static wchar_t* known_ie_window_classes[] = {
L"IEFrame",
L"TabWindowClass"
};
for (int i = 0; i < ARRAYSIZE(known_ie_window_classes); i++) {
if (IsWindowOfClass(window_to_check, known_ie_window_classes[i])) {
is_browser_window = true;
break;
}
}
return is_browser_window;
}
HRESULT UtilGetWebBrowserObjectFromWindow(HWND window,
REFIID iid,
void** web_browser_object) {
if (NULL == web_browser_object) {
return E_POINTER;
}
// Check whether this window is really a web browser window.
if (UtilIsWebBrowserWindow(window)) {
// IWebBroswer2 interface pointer can be retrieved from the browser
// window by simply sending a registered message "GetAutomationObject"
// Note that since we are sending a message to parent window make sure that
// it is in the same thread.
if (GetWindowThreadProcessId(window, NULL) != GetCurrentThreadId()) {
return E_UNEXPECTED;
}
static const ULONG get_browser_message =
RegisterWindowMessageW(kGetBrowserMessage);
*web_browser_object =
reinterpret_cast<void*>(SendMessage(window,
get_browser_message,
reinterpret_cast<WPARAM>(&iid),
NULL));
if (NULL != *web_browser_object) {
return S_OK;
}
} else {
return E_INVALIDARG;
}
return E_NOINTERFACE;
}
bool IsWindowOfClass(HWND window_to_check, const wchar_t* window_class) {
bool window_matches = false;
const int buf_size = MAX_PATH;
wchar_t buffer[buf_size] = {0};
DWORD size = GetClassNameW(window_to_check, buffer, buf_size);
// If the window name is any longer than this, it isn't the one we want.
if (size < (buf_size - 1)) {
if (!lstrcmpiW(window_class, buffer)) {
window_matches = true;
}
}
return window_matches;
}
bool IsNamedWindow(HWND window, const wchar_t* window_name) {
bool window_matches = false;
const int buf_size = MAX_PATH;
wchar_t buffer[buf_size] = {0};
DWORD size = GetWindowText(window, buffer, buf_size);
if (size < (buf_size - 1)) {
if (!lstrcmpiW(window_name, buffer)) {
window_matches = true;
}
}
return window_matches;
}
bool IsNamedProcess(const wchar_t* process_name) {
wchar_t file_path[2048] = {0};
GetModuleFileName(NULL, file_path, 2047);
wchar_t* file_name = PathFindFileName(file_path);
return (0 == lstrcmpiW(file_name, process_name));
}
namespace {
struct FindWindowParams {
HWND parent_;
const wchar_t* class_name_;
const wchar_t* window_name_;
HWND window_found_;
DWORD thread_id_;
DWORD process_id_;
FindWindowParams(HWND parent,
const wchar_t* class_name,
const wchar_t* window_name,
DWORD thread_id,
DWORD process_id)
: parent_(parent),
class_name_(class_name),
window_name_(window_name),
window_found_(NULL),
thread_id_(thread_id),
process_id_(process_id) {
}
};
// Checks a window against a set of parameters defined in params. If the
// window matches, fills in params->window_found_ with the HWND of the window
// and returns true. Returns false otherwise.
bool WindowMatches(HWND window, FindWindowParams* params) {
bool found = false;
DWORD process_id = 0;
DWORD thread_id = GetWindowThreadProcessId(window, &process_id);
// First check that the PID and TID match if we're interested.
if (params->process_id_ == 0 || params->process_id_ == process_id) {
if (params->thread_id_ == 0 || params->thread_id_ == thread_id) {
// Then check that we match on class and window names, again only if
// we're interested.
if ((params->class_name_ == NULL ||
IsWindowOfClass(window, params->class_name_)) &&
(params->window_name_ == NULL) ||
IsNamedWindow(window, params->window_name_)) {
found = true;
params->window_found_ = window;
}
}
}
return found;
}
} // namespace
BOOL CALLBACK WndEnumProc(HWND window, LPARAM lparam) {
FindWindowParams* params = reinterpret_cast<FindWindowParams *>(lparam);
if (!params) {
return FALSE;
}
if (WindowMatches(window, params)) {
// We found a match on a top level window. Return false to stop enumerating.
return FALSE;
} else {
// If criteria not satisfied, let us try child windows.
HWND child_window = RecurseFindWindow(window,
params->class_name_,
params->window_name_,
params->thread_id_,
params->process_id_);
if (child_window != NULL) {
// We found the window we are looking for.
params->window_found_ = child_window;
return FALSE;
}
return TRUE;
}
}
HWND RecurseFindWindow(HWND parent,
const wchar_t* class_name,
const wchar_t* window_name,
DWORD thread_id_to_match,
DWORD process_id_to_match) {
if ((class_name == NULL) && (window_name == NULL)) {
return NULL;
}
FindWindowParams params(parent, class_name, window_name,
thread_id_to_match, process_id_to_match);
EnumChildWindows(parent, WndEnumProc, reinterpret_cast<LPARAM>(¶ms));
return params.window_found_;
}
// TODO(robertshield): This is stolen shamelessly from mini_installer.cc.
// Refactor this before (more) bad things happen.
LONG ReadValue(HKEY key,
const wchar_t* value_name,
size_t value_size,
wchar_t* value) {
DWORD type;
DWORD byte_length = static_cast<DWORD>(value_size * sizeof(wchar_t));
LONG result = ::RegQueryValueEx(key, value_name, NULL, &type,
reinterpret_cast<BYTE*>(value),
&byte_length);
if (result == ERROR_SUCCESS) {
if (type != REG_SZ) {
result = ERROR_NOT_SUPPORTED;
} else if (byte_length == 0) {
*value = L'\0';
} else if (value[byte_length/sizeof(wchar_t) - 1] != L'\0') {
if ((byte_length / sizeof(wchar_t)) < value_size)
value[byte_length / sizeof(wchar_t)] = L'\0';
else
result = ERROR_MORE_DATA;
}
}
return result;
}
bool IsBHOLoadingPolicyRegistered() {
wchar_t bho_clsid_as_string[MAX_PATH] = {0};
int count = StringFromGUID2(CLSID_ChromeFrameBHO, bho_clsid_as_string,
ARRAYSIZE(bho_clsid_as_string));
bool bho_registered = false;
if (count > 0) {
wchar_t reg_path_buffer[MAX_PATH] = {0};
int path_count = _snwprintf(reg_path_buffer,
MAX_PATH - 1,
kBHORegistrationPathFmt,
bho_clsid_as_string);
if (path_count > 0) {
HKEY reg_handle = NULL;
LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
reg_path_buffer,
0,
KEY_QUERY_VALUE,
®_handle);
if (result == ERROR_SUCCESS) {
RegCloseKey(reg_handle);
bho_registered = true;
}
}
}
return bho_registered;
}
bool IsSystemLevelChromeFrameInstalled() {
bool system_level_installed = false;
HKEY reg_handle = NULL;
LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
kChromeFrameClientKey,
0,
KEY_QUERY_VALUE,
®_handle);
if (result == ERROR_SUCCESS) {
wchar_t version_buffer[MAX_PATH] = {0};
result = ReadValue(reg_handle,
kGoogleUpdateVersionValue,
MAX_PATH,
version_buffer);
if (result == ERROR_SUCCESS && version_buffer[0] != L'\0') {
system_level_installed = true;
}
RegCloseKey(reg_handle);
}
return system_level_installed;
}