chrome/installer/util/html_dialog_impl.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 <windows.h>
   6 #include <mshtmhst.h>
   7 #include <urlmon.h>
   8
   9 #include "base/win/scoped_variant.h"
  10 #include "chrome/installer/util/html_dialog.h"
  11
  12 #pragma comment(lib, "urlmon.lib")
  13
  14 namespace installer {
  15
  16 // Windows implementation of the HTML dialog class. The main danger with
  17 // using the IE embedded control as a child window of a custom window is that
  18 // it still contains too much browser functionality, allowing the user to do
  19 // things that are not expected of a plain dialog. ShowHTMLDialog API solves
  20 // that problem but gives us a not very customizable frame. We solve that
  21 // using hooks to end up with a robust dialog at the expense of having to do
  22 // the buttons in html itself, like so:
  23 //
  24 // <form onsubmit="submit_it(this); return false;">
  25 //  <input name="accept" type="checkbox" /> My cool option
  26 //  <input name="submit" type="submit" value="[accept]" />
  27 // </form>
  28 //
  29 // function submit_it(f) {
  30 //  if (f.accept.checked) {
  31 //    window.returnValue = 1;  <-- this matches HTML_DLG_ACCEPT
  32 //  } else {
  33 //    window.returnValue = 2;  <-- this matches HTML_DLG_DECLINE
  34 //  }
  35 //  window.close();
  36 // }
  37 //
  38 // Note that on the submit handler you need to set window.returnValue to one of
  39 // the values of DialogResult and call window.close().
  40
  41 class HTMLDialogWin : public HTMLDialog {
  42  public:
  43   HTMLDialogWin(const std::wstring& url, const std::wstring& param)
  44       : url_(url), param_(param) {
  45     if (!mshtml_)
  46        mshtml_ = LoadLibrary(L"MSHTML.DLL");
  47   }
  48
  49   virtual DialogResult ShowModal(void* parent_window,
  50                                  CustomizationCallback* callback) {
  51     int result = HTML_DLG_DECLINE;
  52     if (!InternalDoDialog(callback, &result))
  53       return HTML_DLG_ERROR;
  54     return static_cast<DialogResult>(result);
  55   }
  56
  57   virtual std::wstring GetExtraResult() {
  58     return extra_result_;
  59   }
  60
  61  private:
  62   bool InternalDoDialog(CustomizationCallback* callback, int* result);
  63   static LRESULT CALLBACK MsgFilter(int code, WPARAM wParam, LPARAM lParam);
  64
  65   std::wstring url_;
  66   std::wstring param_;
  67   static HHOOK hook_;
  68   static HINSTANCE mshtml_;
  69   static CustomizationCallback* callback_;
  70   std::wstring extra_result_;
  71 };
  72
  73 HTMLDialog* CreateNativeHTMLDialog(const std::wstring& url,
  74                                    const std::wstring& param) {
  75   return new HTMLDialogWin(url, param);
  76 }
  77
  78 HHOOK HTMLDialogWin::hook_ = NULL;
  79 HINSTANCE HTMLDialogWin::mshtml_ = NULL;
  80 HTMLDialogWin::CustomizationCallback* HTMLDialogWin::callback_ = NULL;
  81
  82 // This hook function gets called for messages bound to the windows that
  83 // ShowHTMLDialog creates. We tell apart the top window because it has the
  84 // system menu style.
  85 LRESULT HTMLDialogWin::MsgFilter(int code, WPARAM wParam, LPARAM lParam) {
  86   static bool tweak_window = true;
  87   if (lParam && tweak_window) {
  88     HWND target_window = reinterpret_cast<MSG*>(lParam)->hwnd;
  89     if (target_window) {
  90       LONG_PTR style = ::GetWindowLongPtrW(target_window, GWL_STYLE);
  91       if (style & WS_SYSMENU) {
  92         tweak_window = false;
  93         callback_->OnBeforeDisplay(target_window);
  94       }
  95     }
  96   }
  97   // Always call the next hook in the chain.
  98   return ::CallNextHookEx(hook_, code, wParam, lParam);
  99 }
 100
 101 bool HTMLDialogWin::InternalDoDialog(CustomizationCallback* callback,
 102                                      int* result) {
 103   if (!mshtml_)
 104     return false;
 105   SHOWHTMLDIALOGFN* show_html_dialog =
 106       reinterpret_cast<SHOWHTMLDIALOGFN*>(
 107           GetProcAddress(mshtml_, "ShowHTMLDialog"));
 108   if (!show_html_dialog)
 109     return false;
 110
 111   IMoniker *url_moniker = NULL;
 112   ::CreateURLMonikerEx(NULL, url_.c_str(), &url_moniker, URL_MK_UNIFORM);
 113   if (!url_moniker)
 114     return false;
 115
 116   wchar_t* extra_args = NULL;
 117   if (callback) {
 118     callback->OnBeforeCreation(&extra_args);
 119     // Sets a windows hook for this thread only.
 120     hook_ = ::SetWindowsHookEx(WH_GETMESSAGE, MsgFilter, NULL,
 121                                GetCurrentThreadId());
 122     if (hook_)
 123       callback_ = callback;
 124   }
 125
 126   // Pass our parameter to the dialog in the dialogArguments property of
 127   // the window object.
 128   base::win::ScopedVariant dialog_args(param_.c_str());
 129
 130   VARIANT v_result;
 131   ::VariantInit(&v_result);
 132
 133   // Creates the window with the embedded IE control in a modal loop.
 134   HRESULT hr = show_html_dialog(NULL,
 135                                 url_moniker,
 136                                 dialog_args.AsInput(),
 137                                 extra_args,
 138                                 &v_result);
 139   url_moniker->Release();
 140
 141   if (v_result.vt == VT_I4) {
 142     *result = v_result.intVal;
 143   } else if (v_result.vt == VT_BSTR) {
 144     *result = HTML_DLG_EXTRA;
 145     extra_result_.assign(v_result.bstrVal, SysStringLen(v_result.bstrVal));
 146   }
 147
 148   ::VariantClear(&v_result);
 149
 150   if (hook_) {
 151     ::UnhookWindowsHookEx(hook_);
 152     callback_ = NULL;
 153     hook_ = NULL;
 154   }
 155   return SUCCEEDED(hr);
 156 }
 157
 158 // EulaHTMLDialog implementation ---------------------------------------------
 159
 160 void EulaHTMLDialog::Customizer::OnBeforeCreation(wchar_t** extra) {
 161 }
 162
 163 // The customization of the window consists in removing the close button and
 164 // replacing the existing 'e' icon with the standard informational icon.
 165 void EulaHTMLDialog::Customizer::OnBeforeDisplay(void* window) {
 166   if (!window)
 167     return;
 168   HWND top_window = static_cast<HWND>(window);
 169   LONG_PTR style = ::GetWindowLongPtrW(top_window, GWL_STYLE);
 170   ::SetWindowLongPtrW(top_window, GWL_STYLE, style & ~WS_SYSMENU);
 171   HICON ico = ::LoadIcon(NULL, IDI_INFORMATION);
 172   ::SendMessageW(top_window, WM_SETICON, ICON_SMALL,
 173                  reinterpret_cast<LPARAM>(ico));
 174 }
 175
 176 EulaHTMLDialog::EulaHTMLDialog(const std::wstring& file,
 177                                const std::wstring& param) {
 178   dialog_ = CreateNativeHTMLDialog(file, param);
 179 }
 180
 181 EulaHTMLDialog::~EulaHTMLDialog() {
 182   delete dialog_;
 183 }
 184
 185 EulaHTMLDialog::Outcome EulaHTMLDialog::ShowModal() {
 186   Customizer customizer;
 187   HTMLDialog::DialogResult dr = dialog_->ShowModal(NULL, &customizer);
 188   if (HTMLDialog::HTML_DLG_ACCEPT == dr)
 189     return EulaHTMLDialog::ACCEPTED;
 190   else if (HTMLDialog::HTML_DLG_EXTRA == dr)
 191     return EulaHTMLDialog::ACCEPTED_OPT_IN;
 192   else
 193     return EulaHTMLDialog::REJECTED;
 194 }
 195
 196 }  // namespace installer