chrome_frame/chrome_frame_activex.cc

   1 // Copyright (c) 2012 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_activex.h"
   6
   7 #include <wininet.h>
   8
   9 #include <algorithm>
  10 #include <map>
  11
  12 #include "base/basictypes.h"
  13 #include "base/command_line.h"
  14 #include "base/debug/trace_event.h"
  15 #include "base/logging.h"
  16 #include "base/memory/singleton.h"
  17 #include "base/path_service.h"
  18 #include "base/strings/string_split.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/win/scoped_bstr.h"
  23 #include "base/win/scoped_variant.h"
  24 #include "chrome/common/automation_messages.h"
  25 #include "chrome/common/chrome_constants.h"
  26 #include "chrome/common/chrome_switches.h"
  27 #include "chrome/test/automation/tab_proxy.h"
  28 #include "chrome_frame/utils.h"
  29 #include "url/gurl.h"
  30
  31 namespace {
  32
  33 // Class used to maintain a mapping from top-level windows to ChromeFrameActivex
  34 // instances.
  35 class TopLevelWindowMapping {
  36  public:
  37   typedef std::vector<HWND> WindowList;
  38
  39   static TopLevelWindowMapping* GetInstance() {
  40     return Singleton<TopLevelWindowMapping>::get();
  41   }
  42
  43   // Add |cf_window| to the set of windows registered under |top_window|.
  44   void AddMapping(HWND top_window, HWND cf_window) {
  45     top_window_map_lock_.Lock();
  46     top_window_map_[top_window].push_back(cf_window);
  47     top_window_map_lock_.Unlock();
  48   }
  49
  50   // Return the set of Chrome-Frame instances under |window|.
  51   WindowList GetInstances(HWND window) {
  52     top_window_map_lock_.Lock();
  53     WindowList list = top_window_map_[window];
  54     top_window_map_lock_.Unlock();
  55     return list;
  56   }
  57
  58  private:
  59   // Constructor is private as this class it to be used as a singleton.
  60   // See static method instance().
  61   TopLevelWindowMapping() {}
  62
  63   friend struct DefaultSingletonTraits<TopLevelWindowMapping>;
  64
  65   typedef std::map<HWND, WindowList> TopWindowMap;
  66   TopWindowMap top_window_map_;
  67
  68   CComAutoCriticalSection top_window_map_lock_;
  69
  70   DISALLOW_COPY_AND_ASSIGN(TopLevelWindowMapping);
  71 };
  72
  73 // Message pump hook function that monitors for WM_MOVE and WM_MOVING
  74 // messages on a top-level window, and passes notification to the appropriate
  75 // Chrome-Frame instances.
  76 LRESULT CALLBACK TopWindowProc(int code, WPARAM wparam, LPARAM lparam) {
  77   CWPSTRUCT* info = reinterpret_cast<CWPSTRUCT*>(lparam);
  78   const UINT &message = info->message;
  79   const HWND &message_hwnd = info->hwnd;
  80
  81   switch (message) {
  82     case WM_MOVE:
  83     case WM_MOVING: {
  84       TopLevelWindowMapping::WindowList cf_instances =
  85           TopLevelWindowMapping::GetInstance()->GetInstances(message_hwnd);
  86       TopLevelWindowMapping::WindowList::iterator
  87           iter(cf_instances.begin()), end(cf_instances.end());
  88       for (; iter != end; ++iter) {
  89         PostMessage(*iter, WM_HOST_MOVED_NOTIFICATION, NULL, NULL);
  90       }
  91       break;
  92     }
  93     default:
  94       break;
  95   }
  96
  97   return CallNextHookEx(0, code, wparam, lparam);
  98 }
  99
 100 HHOOK InstallLocalWindowHook(HWND window) {
 101   if (!window)
 102     return NULL;
 103
 104   DWORD proc_thread = ::GetWindowThreadProcessId(window, NULL);
 105   if (!proc_thread)
 106     return NULL;
 107
 108   // Note that this hook is installed as a LOCAL hook.
 109   return  ::SetWindowsHookEx(WH_CALLWNDPROC,
 110                              TopWindowProc,
 111                              NULL,
 112                              proc_thread);
 113 }
 114
 115 }  // unnamed namespace
 116
 117 namespace chrome_frame {
 118 std::string ActiveXCreateUrl(const GURL& parsed_url,
 119                              const AttachExternalTabParams& params) {
 120   return base::StringPrintf(
 121       "%hs?attach_external_tab&%I64u&%d&%d&%d&%d&%d&%hs",
 122       parsed_url.GetOrigin().spec().c_str(),
 123       params.cookie,
 124       params.disposition,
 125       params.dimensions.x(),
 126       params.dimensions.y(),
 127       params.dimensions.width(),
 128       params.dimensions.height(),
 129       params.profile_name.c_str());
 130 }
 131
 132 int GetDisposition(const AttachExternalTabParams& params) {
 133   return params.disposition;
 134 }
 135
 136 void GetMiniContextMenuData(UINT cmd,
 137                             const MiniContextMenuParams& params,
 138                             GURL* referrer,
 139                             GURL* url) {
 140   *referrer = params.frame_url.is_empty() ? params.page_url : params.frame_url;
 141   *url = (cmd == IDS_CONTENT_CONTEXT_SAVELINKAS ?
 142       params.link_url : params.src_url);
 143 }
 144
 145 }  // namespace chrome_frame
 146
 147 ChromeFrameActivex::ChromeFrameActivex()
 148     : chrome_wndproc_hook_(NULL),
 149       attaching_to_existing_cf_tab_(false) {
 150   TRACE_EVENT_BEGIN_ETW("chromeframe.createactivex", this, "");
 151 }
 152
 153 HRESULT ChromeFrameActivex::FinalConstruct() {
 154   HRESULT hr = Base::FinalConstruct();
 155   if (FAILED(hr))
 156     return hr;
 157
 158   // No need to call FireOnChanged at this point since nobody will be listening.
 159   ready_state_ = READYSTATE_LOADING;
 160   return S_OK;
 161 }
 162
 163 ChromeFrameActivex::~ChromeFrameActivex() {
 164   // We expect these to be released during a call to SetClientSite(NULL).
 165   DCHECK_EQ(0u, onmessage_.size());
 166   DCHECK_EQ(0u, onloaderror_.size());
 167   DCHECK_EQ(0u, onload_.size());
 168   DCHECK_EQ(0u, onreadystatechanged_.size());
 169   DCHECK_EQ(0u, onextensionready_.size());
 170
 171   if (chrome_wndproc_hook_) {
 172     BOOL unhook_success = ::UnhookWindowsHookEx(chrome_wndproc_hook_);
 173     DCHECK(unhook_success);
 174   }
 175
 176   // ChromeFramePlugin::Uninitialize()
 177   Base::Uninitialize();
 178
 179   TRACE_EVENT_END_ETW("chromeframe.createactivex", this, "");
 180 }
 181
 182 LRESULT ChromeFrameActivex::OnCreate(UINT message, WPARAM wparam, LPARAM lparam,
 183                                      BOOL& handled) {
 184   Base::OnCreate(message, wparam, lparam, handled);
 185   // Install the notification hook on the top-level window, so that we can
 186   // be notified on move events.  Note that the return value is not checked.
 187   // This hook is installed here, as opposed to during IOleObject_SetClientSite
 188   // because m_hWnd has not yet been assigned during the SetSite call.
 189   InstallTopLevelHook(m_spClientSite);
 190   return 0;
 191 }
 192
 193 LRESULT ChromeFrameActivex::OnHostMoved(UINT message, WPARAM wparam,
 194                                         LPARAM lparam, BOOL& handled) {
 195   Base::OnHostMoved();
 196   return 0;
 197 }
 198
 199 HRESULT ChromeFrameActivex::GetContainingDocument(IHTMLDocument2** doc) {
 200   base::win::ScopedComPtr<IOleContainer> container;
 201   HRESULT hr = m_spClientSite->GetContainer(container.Receive());
 202   if (container)
 203     hr = container.QueryInterface(doc);
 204   return hr;
 205 }
 206
 207 HRESULT ChromeFrameActivex::GetDocumentWindow(IHTMLWindow2** window) {
 208   base::win::ScopedComPtr<IHTMLDocument2> document;
 209   HRESULT hr = GetContainingDocument(document.Receive());
 210   if (document)
 211     hr = document->get_parentWindow(window);
 212   return hr;
 213 }
 214
 215 void ChromeFrameActivex::OnLoad(const GURL& gurl) {
 216   base::win::ScopedComPtr<IDispatch> event;
 217   std::string url = gurl.spec();
 218   if (SUCCEEDED(CreateDomEvent("event", url, "", event.Receive())))
 219     Fire_onload(event);
 220
 221   FireEvent(onload_, url);
 222   Base::OnLoad(gurl);
 223 }
 224
 225 void ChromeFrameActivex::OnLoadFailed(int error_code, const std::string& url) {
 226   base::win::ScopedComPtr<IDispatch> event;
 227   if (SUCCEEDED(CreateDomEvent("event", url, "", event.Receive())))
 228     Fire_onloaderror(event);
 229
 230   FireEvent(onloaderror_, url);
 231   Base::OnLoadFailed(error_code, url);
 232 }
 233
 234 void ChromeFrameActivex::OnMessageFromChromeFrame(const std::string& message,
 235                                                   const std::string& origin,
 236                                                   const std::string& target) {
 237   DVLOG(1) << __FUNCTION__;
 238
 239   if (target.compare("*") != 0) {
 240     bool drop = true;
 241
 242     if (is_privileged()) {
 243       // Forward messages if the control is in privileged mode.
 244       base::win::ScopedComPtr<IDispatch> message_event;
 245       if (SUCCEEDED(CreateDomEvent("message", message, origin,
 246                                    message_event.Receive()))) {
 247         base::win::ScopedBstr target_bstr(UTF8ToWide(target).c_str());
 248         Fire_onprivatemessage(message_event, target_bstr);
 249
 250         FireEvent(onprivatemessage_, message_event, target_bstr);
 251       }
 252     } else {
 253       if (HaveSameOrigin(target, document_url_)) {
 254         drop = false;
 255       } else {
 256         DLOG(WARNING) << "Dropping posted message since target doesn't match "
 257             "the current document's origin. target=" << target;
 258       }
 259     }
 260
 261     if (drop)
 262       return;
 263   }
 264
 265   base::win::ScopedComPtr<IDispatch> message_event;
 266   if (SUCCEEDED(CreateDomEvent("message", message, origin,
 267                                message_event.Receive()))) {
 268     Fire_onmessage(message_event);
 269
 270     FireEvent(onmessage_, message_event);
 271
 272     base::win::ScopedVariant event_var;
 273     event_var.Set(static_cast<IDispatch*>(message_event));
 274     InvokeScriptFunction(onmessage_handler_, event_var.AsInput());
 275   }
 276 }
 277
 278 bool ChromeFrameActivex::ShouldShowVersionMismatchDialog(
 279     bool is_privileged,
 280     IOleClientSite* client_site) {
 281   if (!is_privileged) {
 282     return true;
 283   }
 284
 285   if (client_site) {
 286     base::win::ScopedComPtr<IChromeFramePrivileged> service;
 287     HRESULT hr = DoQueryService(SID_ChromeFramePrivileged,
 288                                 client_site,
 289                                 service.Receive());
 290     if (SUCCEEDED(hr) && service) {
 291       return (S_FALSE != service->ShouldShowVersionMismatchDialog());
 292     }
 293   }
 294
 295   NOTREACHED();
 296   return true;
 297 }
 298
 299 void ChromeFrameActivex::OnAutomationServerLaunchFailed(
 300     AutomationLaunchResult reason, const std::string& server_version) {
 301   Base::OnAutomationServerLaunchFailed(reason, server_version);
 302
 303   if (reason == AUTOMATION_VERSION_MISMATCH &&
 304       ShouldShowVersionMismatchDialog(is_privileged(), m_spClientSite)) {
 305     UMA_HISTOGRAM_COUNTS("ChromeFrame.VersionMismatchDisplayed", 1);
 306     DisplayVersionMismatchWarning(m_hWnd, server_version);
 307   }
 308 }
 309
 310 void ChromeFrameActivex::OnChannelError() {
 311   Fire_onchannelerror();
 312 }
 313
 314 HRESULT ChromeFrameActivex::OnDraw(ATL_DRAWINFO& draw_info) {  // NOLINT
 315   HRESULT hr = S_OK;
 316   int dc_type = ::GetObjectType(draw_info.hicTargetDev);
 317   if (dc_type == OBJ_ENHMETADC) {
 318     RECT print_bounds = {0};
 319     print_bounds.left = draw_info.prcBounds->left;
 320     print_bounds.right = draw_info.prcBounds->right;
 321     print_bounds.top = draw_info.prcBounds->top;
 322     print_bounds.bottom = draw_info.prcBounds->bottom;
 323
 324     automation_client_->Print(draw_info.hdcDraw, print_bounds);
 325   } else {
 326     hr = Base::OnDraw(draw_info);
 327   }
 328
 329   return hr;
 330 }
 331
 332 STDMETHODIMP ChromeFrameActivex::Load(IPropertyBag* bag, IErrorLog* error_log) {
 333   DCHECK(bag);
 334
 335   const wchar_t* event_props[] = {
 336     (L"onload"),
 337     (L"onloaderror"),
 338     (L"onmessage"),
 339     (L"onreadystatechanged"),
 340   };
 341
 342   base::win::ScopedComPtr<IHTMLObjectElement> obj_element;
 343   GetObjectElement(obj_element.Receive());
 344
 345   base::win::ScopedBstr object_id;
 346   GetObjectScriptId(obj_element, object_id.Receive());
 347
 348   base::win::ScopedComPtr<IHTMLElement2> element;
 349   element.QueryFrom(obj_element);
 350   HRESULT hr = S_OK;
 351
 352   for (int i = 0; SUCCEEDED(hr) && i < arraysize(event_props); ++i) {
 353     base::win::ScopedBstr prop(event_props[i]);
 354     base::win::ScopedVariant value;
 355     if (SUCCEEDED(bag->Read(prop, value.Receive(), error_log))) {
 356       if (value.type() != VT_BSTR ||
 357           FAILED(hr = CreateScriptBlockForEvent(element, object_id,
 358                                                 V_BSTR(&value), prop))) {
 359         DLOG(ERROR) << "Failed to create script block for " << prop
 360                     << base::StringPrintf(L"hr=0x%08X, vt=%i", hr,
 361                                          value.type());
 362       } else {
 363         DVLOG(1) << "script block created for event " << prop
 364                  << base::StringPrintf(" (0x%08X)", hr) << " connections: " <<
 365             ProxyDIChromeFrameEvents<ChromeFrameActivex>::m_vec.GetSize();
 366       }
 367     } else {
 368       DVLOG(1) << "event property " << prop << " not in property bag";
 369     }
 370   }
 371
 372   base::win::ScopedVariant src;
 373   if (SUCCEEDED(bag->Read(base::win::ScopedBstr(L"src"), src.Receive(),
 374                           error_log))) {
 375     if (src.type() == VT_BSTR) {
 376       hr = put_src(V_BSTR(&src));
 377       DCHECK(hr != E_UNEXPECTED);
 378     }
 379   }
 380
 381   base::win::ScopedVariant use_chrome_network;
 382   if (SUCCEEDED(bag->Read(base::win::ScopedBstr(L"useChromeNetwork"),
 383                           use_chrome_network.Receive(), error_log))) {
 384     VariantChangeType(use_chrome_network.AsInput(),
 385                       use_chrome_network.AsInput(),
 386                       0, VT_BOOL);
 387     if (use_chrome_network.type() == VT_BOOL) {
 388       hr = put_useChromeNetwork(V_BOOL(&use_chrome_network));
 389       DCHECK(hr != E_UNEXPECTED);
 390     }
 391   }
 392
 393   DLOG_IF(ERROR, FAILED(hr))
 394       << base::StringPrintf("Failed to load property bag: 0x%08X", hr);
 395
 396   return hr;
 397 }
 398
 399 const wchar_t g_activex_insecure_content_error[] = {
 400     L"data:text/html,<html><body><b>ChromeFrame Security Error<br><br>"
 401     L"Cannot navigate to HTTP url when document URL is HTTPS</body></html>"};
 402
 403 STDMETHODIMP ChromeFrameActivex::put_src(BSTR src) {
 404   GURL document_url(GetDocumentUrl());
 405   if (document_url.SchemeIsSecure()) {
 406     GURL source_url(src);
 407     if (!source_url.SchemeIsSecure()) {
 408       Base::put_src(base::win::ScopedBstr(g_activex_insecure_content_error));
 409       return E_ACCESSDENIED;
 410     }
 411   }
 412   HRESULT hr = S_OK;
 413   // If we are connecting to an existing ExternalTabContainer instance in
 414   // Chrome then we should wait for Chrome to initiate the navigation.
 415   if (!attaching_to_existing_cf_tab_) {
 416     hr = Base::put_src(src);
 417   } else {
 418     url_.Reset(::SysAllocString(src));
 419     attaching_to_existing_cf_tab_ = false;
 420   }
 421   return S_OK;
 422 }
 423
 424 HRESULT ChromeFrameActivex::IOleObject_SetClientSite(
 425     IOleClientSite* client_site) {
 426   HRESULT hr = Base::IOleObject_SetClientSite(client_site);
 427   if (FAILED(hr) || !client_site) {
 428     EventHandlers* handlers[] = {
 429       &onmessage_,
 430       &onloaderror_,
 431       &onload_,
 432       &onreadystatechanged_,
 433       &onextensionready_,
 434     };
 435
 436     for (int i = 0; i < arraysize(handlers); ++i)
 437       handlers[i]->clear();
 438
 439     // Drop privileged mode on uninitialization.
 440     set_is_privileged(false);
 441   } else {
 442     base::win::ScopedComPtr<IHTMLDocument2> document;
 443     GetContainingDocument(document.Receive());
 444     if (document) {
 445       base::win::ScopedBstr url;
 446       if (SUCCEEDED(document->get_URL(url.Receive())))
 447         WideToUTF8(url, url.Length(), &document_url_);
 448     }
 449
 450     // Probe to see whether the host implements the privileged service.
 451     base::win::ScopedComPtr<IChromeFramePrivileged> service;
 452     HRESULT service_hr = DoQueryService(SID_ChromeFramePrivileged,
 453                                         m_spClientSite,
 454                                         service.Receive());
 455     if (SUCCEEDED(service_hr) && service) {
 456       // Does the host want privileged mode?
 457       boolean wants_privileged = false;
 458       service_hr = service->GetWantsPrivileged(&wants_privileged);
 459
 460       if (SUCCEEDED(service_hr) && wants_privileged)
 461         set_is_privileged(true);
 462
 463       url_fetcher_->set_privileged_mode(is_privileged());
 464     }
 465
 466     std::wstring profile_name(GetHostProcessName(false));
 467     if (is_privileged()) {
 468       base::win::ScopedBstr profile_name_arg;
 469       service_hr = service->GetChromeProfileName(profile_name_arg.Receive());
 470       if (S_OK == service_hr && profile_name_arg)
 471         profile_name.assign(profile_name_arg, profile_name_arg.Length());
 472     }
 473
 474     std::string utf8_url;
 475     if (url_.Length()) {
 476       WideToUTF8(url_, url_.Length(), &utf8_url);
 477     }
 478
 479     InitializeAutomationSettings();
 480
 481     if (service) {
 482       base::win::ScopedBstr navigation_url;
 483       service->GetNavigationUrl(navigation_url.Receive());
 484       if (navigation_url.Length()) {
 485         ChromeFrameUrl cf_url;
 486         cf_url.Parse(navigation_url.operator BSTR());
 487         if (cf_url.attach_to_external_tab()) {
 488           automation_client_->AttachExternalTab(cf_url.cookie());
 489           attaching_to_existing_cf_tab_ = true;
 490         }
 491       }
 492     }
 493     url_fetcher_->set_frame_busting(!is_privileged());
 494     automation_client_->SetUrlFetcher(url_fetcher_.get());
 495     if (!InitializeAutomation(profile_name, IsIEInPrivate(), true,
 496                               GURL(utf8_url), GURL(), false)) {
 497       DLOG(ERROR) << "Failed to navigate to url:" << utf8_url;
 498       return E_FAIL;
 499     }
 500
 501     // Log a metric that Chrome Frame is being used in Widget mode
 502     UMA_LAUNCH_TYPE_COUNT(RENDERER_TYPE_CHROME_WIDGET);
 503   }
 504
 505   return hr;
 506 }
 507
 508 HRESULT ChromeFrameActivex::GetObjectScriptId(IHTMLObjectElement* object_elem,
 509                                               BSTR* id) {
 510   DCHECK(object_elem != NULL);
 511   DCHECK(id != NULL);
 512
 513   HRESULT hr = E_FAIL;
 514   if (object_elem) {
 515     base::win::ScopedComPtr<IHTMLElement> elem;
 516     hr = elem.QueryFrom(object_elem);
 517     if (elem) {
 518       hr = elem->get_id(id);
 519     }
 520   }
 521
 522   return hr;
 523 }
 524
 525 HRESULT ChromeFrameActivex::GetObjectElement(IHTMLObjectElement** element) {
 526   DCHECK(m_spClientSite);
 527   if (!m_spClientSite)
 528     return E_UNEXPECTED;
 529
 530   base::win::ScopedComPtr<IOleControlSite> site;
 531   HRESULT hr = site.QueryFrom(m_spClientSite);
 532   if (site) {
 533     base::win::ScopedComPtr<IDispatch> disp;
 534     hr = site->GetExtendedControl(disp.Receive());
 535     if (disp) {
 536       hr = disp.QueryInterface(element);
 537     } else {
 538       DCHECK(FAILED(hr));
 539     }
 540   }
 541
 542   return hr;
 543 }
 544
 545 HRESULT ChromeFrameActivex::CreateScriptBlockForEvent(
 546     IHTMLElement2* insert_after, BSTR instance_id, BSTR script,
 547     BSTR event_name) {
 548   DCHECK(insert_after);
 549   DCHECK_GT(::SysStringLen(event_name), 0UL);  // should always have this
 550
 551   // This might be 0 if not specified in the HTML document.
 552   if (!::SysStringLen(instance_id)) {
 553     // TODO(tommi): Should we give ourselves an ID if this happens?
 554     NOTREACHED() << "Need to handle this";
 555     return E_INVALIDARG;
 556   }
 557
 558   base::win::ScopedComPtr<IHTMLDocument2> document;
 559   HRESULT hr = GetContainingDocument(document.Receive());
 560   if (SUCCEEDED(hr)) {
 561     base::win::ScopedComPtr<IHTMLElement> element, new_element;
 562     document->createElement(base::win::ScopedBstr(L"script"),
 563                             element.Receive());
 564     if (element) {
 565       base::win::ScopedComPtr<IHTMLScriptElement> script_element;
 566       if (SUCCEEDED(hr = script_element.QueryFrom(element))) {
 567         script_element->put_htmlFor(instance_id);
 568         script_element->put_event(event_name);
 569         script_element->put_text(script);
 570
 571         hr = insert_after->insertAdjacentElement(
 572             base::win::ScopedBstr(L"afterEnd"),
 573             element,
 574             new_element.Receive());
 575       }
 576     }
 577   }
 578
 579   return hr;
 580 }
 581
 582 void ChromeFrameActivex::FireEvent(const EventHandlers& handlers,
 583                                    const std::string& arg) {
 584   if (handlers.size()) {
 585     base::win::ScopedComPtr<IDispatch> event;
 586     if (SUCCEEDED(CreateDomEvent("event", arg, "", event.Receive()))) {
 587       FireEvent(handlers, event);
 588     }
 589   }
 590 }
 591
 592 void ChromeFrameActivex::FireEvent(const EventHandlers& handlers,
 593                                    IDispatch* event) {
 594   DCHECK(event != NULL);
 595   VARIANT arg = { VT_DISPATCH };
 596   arg.pdispVal = event;
 597   DISPPARAMS params = { &arg, NULL, 1, 0 };
 598   for (EventHandlers::const_iterator it = handlers.begin();
 599        it != handlers.end();
 600        ++it) {
 601     HRESULT hr = (*it)->Invoke(DISPID_VALUE, IID_NULL, LOCALE_USER_DEFAULT,
 602                                DISPATCH_METHOD, &params, NULL, NULL, NULL);
 603     // 0x80020101 == SCRIPT_E_REPORTED.
 604     // When the script we're invoking has an error, we get this error back.
 605     DLOG_IF(ERROR, FAILED(hr) && hr != 0x80020101)
 606         << base::StringPrintf(L"Failed to invoke script: 0x%08X", hr);
 607   }
 608 }
 609
 610 void ChromeFrameActivex::FireEvent(const EventHandlers& handlers,
 611                                    IDispatch* event, BSTR target) {
 612   DCHECK(event != NULL);
 613   // Arguments in reverse order to event handler function declaration,
 614   // because that's what DISPPARAMS requires.
 615   VARIANT args[2] = { { VT_BSTR }, { VT_DISPATCH }, };
 616   args[0].bstrVal = target;
 617   args[1].pdispVal = event;
 618   DISPPARAMS params = { args, NULL, arraysize(args), 0 };
 619   for (EventHandlers::const_iterator it = handlers.begin();
 620        it != handlers.end();
 621        ++it) {
 622     HRESULT hr = (*it)->Invoke(DISPID_VALUE, IID_NULL, LOCALE_USER_DEFAULT,
 623                                DISPATCH_METHOD, &params, NULL, NULL, NULL);
 624     // 0x80020101 == SCRIPT_E_REPORTED.
 625     // When the script we're invoking has an error, we get this error back.
 626     DLOG_IF(ERROR, FAILED(hr) && hr != 0x80020101)
 627         << base::StringPrintf(L"Failed to invoke script: 0x%08X", hr);
 628   }
 629 }
 630
 631 HRESULT ChromeFrameActivex::InstallTopLevelHook(IOleClientSite* client_site) {
 632   // Get the parent window of the site, and install our hook on the topmost
 633   // window of the parent.
 634   base::win::ScopedComPtr<IOleWindow> ole_window;
 635   HRESULT hr = ole_window.QueryFrom(client_site);
 636   if (FAILED(hr))
 637     return hr;
 638
 639   HWND parent_wnd;
 640   hr = ole_window->GetWindow(&parent_wnd);
 641   if (FAILED(hr))
 642     return hr;
 643
 644   HWND top_window = ::GetAncestor(parent_wnd, GA_ROOT);
 645   chrome_wndproc_hook_ = InstallLocalWindowHook(top_window);
 646   if (chrome_wndproc_hook_)
 647     TopLevelWindowMapping::GetInstance()->AddMapping(top_window, m_hWnd);
 648
 649   return chrome_wndproc_hook_ ? S_OK : E_FAIL;
 650 }
 651
 652 HRESULT ChromeFrameActivex::registerBhoIfNeeded() {
 653   if (!m_spUnkSite) {
 654     NOTREACHED() << "Invalid client site";
 655     return E_FAIL;
 656   }
 657
 658   if (NavigationManager::GetThreadInstance() != NULL) {
 659     DVLOG(1) << "BHO already loaded";
 660     return S_OK;
 661   }
 662
 663   base::win::ScopedComPtr<IWebBrowser2> web_browser2;
 664   HRESULT hr = DoQueryService(SID_SWebBrowserApp, m_spUnkSite,
 665                               web_browser2.Receive());
 666   if (FAILED(hr) || web_browser2.get() == NULL) {
 667     DLOG(WARNING) << "Failed to get IWebBrowser2 from client site. Error:"
 668                   << base::StringPrintf(" 0x%08X", hr);
 669     return hr;
 670   }
 671
 672   wchar_t bho_class_id_as_string[MAX_PATH] = {0};
 673   StringFromGUID2(CLSID_ChromeFrameBHO, bho_class_id_as_string,
 674                   arraysize(bho_class_id_as_string));
 675
 676   base::win::ScopedComPtr<IObjectWithSite> bho;
 677   hr = bho.CreateInstance(CLSID_ChromeFrameBHO, NULL, CLSCTX_INPROC_SERVER);
 678   if (FAILED(hr)) {
 679     NOTREACHED() << "Failed to register ChromeFrame BHO. Error:"
 680                  << base::StringPrintf(" 0x%08X", hr);
 681     return hr;
 682   }
 683
 684   hr = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT_REFRESH, NULL, 0, 0);
 685   if (FAILED(hr)) {
 686     DLOG(ERROR) << "Failed to refresh user agent string from registry. "
 687                 << "UrlMkSetSessionOption returned "
 688                 << base::StringPrintf("0x%08x", hr);
 689     return hr;
 690   }
 691
 692   hr = bho->SetSite(web_browser2);
 693   if (FAILED(hr)) {
 694     NOTREACHED() << "ChromeFrame BHO SetSite failed. Error:"
 695                  << base::StringPrintf(" 0x%08X", hr);
 696     return hr;
 697   }
 698
 699   web_browser2->PutProperty(base::win::ScopedBstr(bho_class_id_as_string),
 700                             base::win::ScopedVariant(bho));
 701   return S_OK;
 702 }