path: root/chrome_frame/chrome_frame_helper_util.cc

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