chrome_frame/chrome_frame_helper_util.cc

   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>(&params));
 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                                  &reg_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                              &reg_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