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 // Implementation of ChromeActiveDocument 6 #include "chrome_frame/chrome_active_document.h" 7 8 #include <hlink.h> 9 #include <htiface.h> 10 #include <initguid.h> 11 #include <mshtmcid.h> 12 #include <shdeprecated.h> 13 #include <shlguid.h> 14 #include <shlobj.h> 15 #include <shobjidl.h> 16 #include <tlogstg.h> 17 #include <urlmon.h> 18 #include <wininet.h> 19 20 #include "base/command_line.h" 21 #include "base/debug/trace_event.h" 22 #include "base/logging.h" 23 #include "base/strings/string_util.h" 24 #include "base/strings/utf_string_conversions.h" 25 #include "base/win/scoped_variant.h" 26 #include "chrome/app/chrome_command_ids.h" 27 #include "chrome/app/chrome_dll_resource.h" 28 #include "chrome/common/automation_messages.h" 29 #include "chrome/common/chrome_constants.h" 30 #include "chrome/test/automation/browser_proxy.h" 31 #include "chrome/test/automation/tab_proxy.h" 32 #include "chrome_frame/bho.h" 33 #include "chrome_frame/bind_context_info.h" 34 #include "chrome_frame/buggy_bho_handling.h" 35 #include "chrome_frame/crash_reporting/crash_metrics.h" 36 #include "chrome_frame/utils.h" 37 #include "content/public/browser/invalidate_type.h" 38 #include "content/public/browser/navigation_type.h" 39 #include "content/public/browser/web_contents.h" 40 #include "content/public/common/page_zoom.h" 41 #include "grit/generated_resources.h" 42 43 DEFINE_GUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 44 0x46); 45 46 bool g_first_launch_by_process_ = true; 47 48 const DWORD kIEEncodingIdArray[] = { 49 #define DEFINE_ENCODING_ID_ARRAY(encoding_name, id, chrome_name) encoding_name, 50 INTERNAL_IE_ENCODINGMENU_IDS(DEFINE_ENCODING_ID_ARRAY) 51 #undef DEFINE_ENCODING_ID_ARRAY 52 0 // The Last data must be 0 to indicate the end of the encoding id array. 53 }; 54 55 ChromeActiveDocument::ChromeActiveDocument() 56 : navigation_info_(new NavigationInfo()), 57 first_navigation_(true), 58 is_automation_client_reused_(false), 59 popup_allowed_(false), 60 accelerator_table_(NULL) { 61 TRACE_EVENT_BEGIN_ETW("chromeframe.createactivedocument", this, ""); 62 63 url_fetcher_->set_frame_busting(false); 64 memset(navigation_info_.get(), 0, sizeof(NavigationInfo)); 65 } 66 67 HRESULT ChromeActiveDocument::FinalConstruct() { 68 // The FinalConstruct implementation in the ChromeFrameActivexBase class 69 // i.e. Base creates an instance of the ChromeFrameAutomationClient class 70 // and initializes it, which would spawn a new Chrome process, etc. 71 // We don't want to be doing this if we have a cached document, whose 72 // automation client instance can be reused. 73 HRESULT hr = BaseActiveX::FinalConstruct(); 74 if (FAILED(hr)) 75 return hr; 76 77 InitializeAutomationSettings(); 78 79 find_dialog_.Init(automation_client_.get()); 80 81 OLECMDF flags = static_cast<OLECMDF>(OLECMDF_ENABLED | OLECMDF_SUPPORTED); 82 83 null_group_commands_map_[OLECMDID_PRINT] = flags; 84 null_group_commands_map_[OLECMDID_FIND] = flags; 85 null_group_commands_map_[OLECMDID_CUT] = flags; 86 null_group_commands_map_[OLECMDID_COPY] = flags; 87 null_group_commands_map_[OLECMDID_PASTE] = flags; 88 null_group_commands_map_[OLECMDID_SELECTALL] = flags; 89 null_group_commands_map_[OLECMDID_SAVEAS] = flags; 90 91 mshtml_group_commands_map_[IDM_BASELINEFONT1] = flags; 92 mshtml_group_commands_map_[IDM_BASELINEFONT2] = flags; 93 mshtml_group_commands_map_[IDM_BASELINEFONT3] = flags; 94 mshtml_group_commands_map_[IDM_BASELINEFONT4] = flags; 95 mshtml_group_commands_map_[IDM_BASELINEFONT5] = flags; 96 mshtml_group_commands_map_[IDM_VIEWSOURCE] = flags; 97 98 HMODULE this_module = reinterpret_cast<HMODULE>(&__ImageBase); 99 accelerator_table_ = 100 LoadAccelerators(this_module, 101 MAKEINTRESOURCE(IDR_CHROME_FRAME_IE_FULL_TAB)); 102 DCHECK(accelerator_table_ != NULL); 103 return S_OK; 104 } 105 106 ChromeActiveDocument::~ChromeActiveDocument() { 107 DVLOG(1) << __FUNCTION__; 108 if (find_dialog_.IsWindow()) 109 find_dialog_.DestroyWindow(); 110 // ChromeFramePlugin 111 BaseActiveX::Uninitialize(); 112 113 TRACE_EVENT_END_ETW("chromeframe.createactivedocument", this, ""); 114 } 115 116 // Override DoVerb 117 STDMETHODIMP ChromeActiveDocument::DoVerb(LONG verb, 118 LPMSG msg, 119 IOleClientSite* active_site, 120 LONG index, 121 HWND parent_window, 122 LPCRECT pos) { 123 // IE will try and in-place activate us in some cases. This happens when 124 // the user opens a new IE window with a URL that has us as the DocObject. 125 // Here we refuse to be activated in-place and we will force IE to UIActivate 126 // us. 127 if (OLEIVERB_INPLACEACTIVATE == verb) 128 return OLEOBJ_E_INVALIDVERB; 129 // Check if we should activate as a docobject or not 130 // (client supports IOleDocumentSite) 131 if (doc_site_) { 132 switch (verb) { 133 case OLEIVERB_SHOW: { 134 base::win::ScopedComPtr<IDocHostUIHandler> doc_host_handler; 135 doc_host_handler.QueryFrom(doc_site_); 136 if (doc_host_handler.get()) 137 doc_host_handler->ShowUI(DOCHOSTUITYPE_BROWSE, this, this, NULL, NULL); 138 } 139 case OLEIVERB_OPEN: 140 case OLEIVERB_UIACTIVATE: 141 if (!m_bUIActive) 142 return doc_site_->ActivateMe(NULL); 143 break; 144 } 145 } 146 return IOleObjectImpl<ChromeActiveDocument>::DoVerb(verb, 147 msg, 148 active_site, 149 index, 150 parent_window, 151 pos); 152 } 153 154 // Override IOleInPlaceActiveObjectImpl::OnDocWindowActivate 155 STDMETHODIMP ChromeActiveDocument::OnDocWindowActivate(BOOL activate) { 156 DVLOG(1) << __FUNCTION__; 157 return S_OK; 158 } 159 160 STDMETHODIMP ChromeActiveDocument::TranslateAccelerator(MSG* msg) { 161 DVLOG(1) << __FUNCTION__; 162 if (msg == NULL) 163 return E_POINTER; 164 165 if (msg->message == WM_KEYDOWN && msg->wParam == VK_TAB) { 166 HWND focus = ::GetFocus(); 167 if (focus != m_hWnd && !::IsChild(m_hWnd, focus)) { 168 // The call to SetFocus triggers a WM_SETFOCUS that makes the base class 169 // set focus to the correct element in Chrome. 170 ::SetFocus(m_hWnd); 171 return S_OK; 172 } 173 } 174 175 return S_FALSE; 176 } 177 // Override IPersistStorageImpl::IsDirty 178 STDMETHODIMP ChromeActiveDocument::IsDirty() { 179 DVLOG(1) << __FUNCTION__; 180 return S_FALSE; 181 } 182 183 void ChromeActiveDocument::OnAutomationServerReady() { 184 BaseActiveX::OnAutomationServerReady(); 185 BaseActiveX::GiveFocusToChrome(true); 186 } 187 188 STDMETHODIMP ChromeActiveDocument::Load(BOOL fully_avalable, 189 IMoniker* moniker_name, 190 LPBC bind_context, 191 DWORD mode) { 192 if (NULL == moniker_name) 193 return E_INVALIDARG; 194 195 base::win::ScopedComPtr<IOleClientSite> client_site; 196 if (bind_context) { 197 base::win::ScopedComPtr<IUnknown> site; 198 bind_context->GetObjectParam(SZ_HTML_CLIENTSITE_OBJECTPARAM, 199 site.Receive()); 200 if (site) 201 client_site.QueryFrom(site); 202 } 203 204 if (client_site) { 205 SetClientSite(client_site); 206 DoQueryService(IID_INewWindowManager, client_site, 207 popup_manager_.Receive()); 208 209 // See if mshtml parsed the html header for us. If so, we need to 210 // clear the browser service flag that we use to indicate that this 211 // browser instance is navigating to a CF document. 212 base::win::ScopedComPtr<IBrowserService> browser_service; 213 DoQueryService(SID_SShellBrowser, client_site, browser_service.Receive()); 214 if (browser_service) { 215 bool flagged = CheckForCFNavigation(browser_service, true); 216 DVLOG_IF(1, flagged) << "Cleared flagged browser service"; 217 } 218 } 219 220 NavigationManager* mgr = NavigationManager::GetThreadInstance(); 221 DLOG_IF(ERROR, !mgr) << "Couldn't get instance of NavigationManager"; 222 223 std::wstring url; 224 225 base::win::ScopedComPtr<BindContextInfo> info; 226 BindContextInfo::FromBindContext(bind_context, info.Receive()); 227 DCHECK(info); 228 if (info && !info->GetUrl().empty()) { 229 url = info->GetUrl(); 230 if (mgr) { 231 // If the original URL contains an anchor, then the URL queried 232 // from the protocol sink wrapper does not contain the anchor. To 233 // workaround this we retrieve the anchor from the navigation manager 234 // and append it to the url retrieved from the protocol sink wrapper. 235 GURL url_for_anchor(mgr->url()); 236 if (url_for_anchor.has_ref()) { 237 url += L"#"; 238 url += UTF8ToWide(url_for_anchor.ref()); 239 } 240 } 241 } else { 242 // If the original URL contains an anchor, then the URL queried 243 // from the moniker does not contain the anchor. To workaround 244 // this we retrieve the URL from our BHO. 245 url = GetActualUrlFromMoniker(moniker_name, bind_context, 246 mgr ? mgr->url(): std::wstring()); 247 } 248 249 ChromeFrameUrl cf_url; 250 if (!cf_url.Parse(url)) { 251 DLOG(WARNING) << __FUNCTION__ << " Failed to parse url:" << url; 252 return E_INVALIDARG; 253 } 254 255 std::string referrer(mgr ? mgr->referrer() : std::string()); 256 RendererType renderer_type = cf_url.is_chrome_protocol() ? 257 RENDERER_TYPE_CHROME_GCF_PROTOCOL : RENDERER_TYPE_UNDETERMINED; 258 259 // With CTransaction patch we have more robust way to grab the referrer for 260 // each top-level-switch-to-CF request by peeking at our sniffing data 261 // object that lives inside the bind context. We also remember the reason 262 // we're rendering the document in Chrome. 263 if (g_patch_helper.state() == PatchHelper::PATCH_PROTOCOL && info) { 264 scoped_refptr<ProtData> prot_data = info->get_prot_data(); 265 if (prot_data) { 266 referrer = prot_data->referrer(); 267 renderer_type = prot_data->renderer_type(); 268 } 269 } 270 271 // For gcf: URLs allow only about and view-source schemes to pass through for 272 // further inspection. 273 bool is_safe_scheme = cf_url.gurl().SchemeIs(chrome::kAboutScheme) || 274 cf_url.gurl().SchemeIs(content::kViewSourceScheme); 275 if (cf_url.is_chrome_protocol() && !is_safe_scheme && 276 !GetConfigBool(false, kAllowUnsafeURLs)) { 277 DLOG(ERROR) << __FUNCTION__ << " gcf: not allowed:" << url; 278 return E_INVALIDARG; 279 } 280 281 if (!LaunchUrl(cf_url, referrer)) { 282 DLOG(ERROR) << __FUNCTION__ << " Failed to launch url:" << url; 283 return E_INVALIDARG; 284 } 285 286 if (!cf_url.is_chrome_protocol() && !cf_url.attach_to_external_tab()) 287 url_fetcher_->SetInfoForUrl(url.c_str(), moniker_name, bind_context); 288 289 // Log a metric indicating why GCF is rendering in Chrome. 290 // (Note: we only track the renderer type when using the CTransaction patch. 291 // When the code for the browser service patch and for the moniker patch is 292 // removed, this conditional can also go away.) 293 if (RENDERER_TYPE_UNDETERMINED != renderer_type) { 294 UMA_LAUNCH_TYPE_COUNT(renderer_type); 295 } 296 297 return S_OK; 298 } 299 300 STDMETHODIMP ChromeActiveDocument::Save(IMoniker* moniker_name, 301 LPBC bind_context, 302 BOOL remember) { 303 return E_NOTIMPL; 304 } 305 306 STDMETHODIMP ChromeActiveDocument::SaveCompleted(IMoniker* moniker_name, 307 LPBC bind_context) { 308 return E_NOTIMPL; 309 } 310 311 STDMETHODIMP ChromeActiveDocument::GetCurMoniker(IMoniker** moniker_name) { 312 return E_NOTIMPL; 313 } 314 315 STDMETHODIMP ChromeActiveDocument::GetClassID(CLSID* class_id) { 316 if (NULL == class_id) 317 return E_POINTER; 318 *class_id = GetObjectCLSID(); 319 return S_OK; 320 } 321 322 STDMETHODIMP ChromeActiveDocument::QueryStatus(const GUID* cmd_group_guid, 323 ULONG number_of_commands, 324 OLECMD commands[], 325 OLECMDTEXT* command_text) { 326 DVLOG(1) << __FUNCTION__; 327 328 CommandStatusMap* command_map = NULL; 329 330 if (cmd_group_guid) { 331 if (IsEqualGUID(*cmd_group_guid, GUID_NULL)) { 332 command_map = &null_group_commands_map_; 333 } else if (IsEqualGUID(*cmd_group_guid, CGID_MSHTML)) { 334 command_map = &mshtml_group_commands_map_; 335 } else if (IsEqualGUID(*cmd_group_guid, CGID_Explorer)) { 336 command_map = &explorer_group_commands_map_; 337 } else if (IsEqualGUID(*cmd_group_guid, CGID_ShellDocView)) { 338 command_map = &shdoc_view_group_commands_map_; 339 } 340 } else { 341 command_map = &null_group_commands_map_; 342 } 343 344 if (!command_map) { 345 DVLOG(1) << "unsupported command group: " << GuidToString(*cmd_group_guid); 346 return OLECMDERR_E_NOTSUPPORTED; 347 } 348 349 for (ULONG command_index = 0; command_index < number_of_commands; 350 command_index++) { 351 DVLOG(1) << "Command id = " << commands[command_index].cmdID; 352 CommandStatusMap::iterator index = 353 command_map->find(commands[command_index].cmdID); 354 if (index != command_map->end()) 355 commands[command_index].cmdf = index->second; 356 } 357 return S_OK; 358 } 359 360 STDMETHODIMP ChromeActiveDocument::Exec(const GUID* cmd_group_guid, 361 DWORD command_id, 362 DWORD cmd_exec_opt, 363 VARIANT* in_args, 364 VARIANT* out_args) { 365 DVLOG(1) << __FUNCTION__ << " Cmd id =" << command_id; 366 // Bail out if we have been uninitialized. 367 if (automation_client_.get() && automation_client_->tab()) { 368 return ProcessExecCommand(cmd_group_guid, command_id, cmd_exec_opt, 369 in_args, out_args); 370 } else if (command_id == OLECMDID_REFRESH && cmd_group_guid == NULL) { 371 // If the automation server has crashed and the user is refreshing the 372 // page, let OnRefreshPage attempt to recover. 373 OnRefreshPage(cmd_group_guid, command_id, cmd_exec_opt, in_args, out_args); 374 } 375 376 return OLECMDERR_E_NOTSUPPORTED; 377 } 378 379 STDMETHODIMP ChromeActiveDocument::LoadHistory(IStream* stream, 380 IBindCtx* bind_context) { 381 // Read notes in ChromeActiveDocument::SaveHistory 382 DCHECK(stream); 383 LARGE_INTEGER offset = {0}; 384 ULARGE_INTEGER cur_pos = {0}; 385 STATSTG statstg = {0}; 386 387 stream->Seek(offset, STREAM_SEEK_CUR, &cur_pos); 388 stream->Stat(&statstg, STATFLAG_NONAME); 389 390 DWORD url_size = statstg.cbSize.LowPart - cur_pos.LowPart; 391 base::win::ScopedBstr url_bstr; 392 DWORD bytes_read = 0; 393 stream->Read(url_bstr.AllocateBytes(url_size), url_size, &bytes_read); 394 std::wstring url(url_bstr); 395 396 ChromeFrameUrl cf_url; 397 if (!cf_url.Parse(url)) { 398 DLOG(WARNING) << __FUNCTION__ << " Failed to parse url:" << url; 399 return E_INVALIDARG; 400 } 401 402 if (!LaunchUrl(cf_url, std::string())) { 403 NOTREACHED() << __FUNCTION__ << " Failed to launch url:" << url; 404 return E_INVALIDARG; 405 } 406 return S_OK; 407 } 408 409 STDMETHODIMP ChromeActiveDocument::SaveHistory(IStream* stream) { 410 // TODO(sanjeevr): We need to fetch the entire list of navigation entries 411 // from Chrome and persist it in the stream. And in LoadHistory we need to 412 // pass this list back to Chrome which will recreate the list. This will allow 413 // Back-Forward navigation to anchors to work correctly when we navigate to a 414 // page outside of ChromeFrame and then come back. 415 if (!stream) { 416 NOTREACHED(); 417 return E_INVALIDARG; 418 } 419 420 LARGE_INTEGER offset = {0}; 421 ULARGE_INTEGER new_pos = {0}; 422 DWORD written = 0; 423 std::wstring url = UTF8ToWide(navigation_info_->url.spec()); 424 return stream->Write(url.c_str(), (url.length() + 1) * sizeof(wchar_t), 425 &written); 426 } 427 428 STDMETHODIMP ChromeActiveDocument::SetPositionCookie(DWORD position_cookie) { 429 if (automation_client_.get()) { 430 int index = static_cast<int>(position_cookie); 431 navigation_info_->navigation_index = index; 432 automation_client_->NavigateToIndex(index); 433 } else { 434 DLOG(WARNING) << "Invalid automation client instance"; 435 } 436 return S_OK; 437 } 438 439 STDMETHODIMP ChromeActiveDocument::GetPositionCookie(DWORD* position_cookie) { 440 if (!position_cookie) 441 return E_INVALIDARG; 442 443 *position_cookie = navigation_info_->navigation_index; 444 return S_OK; 445 } 446 447 STDMETHODIMP ChromeActiveDocument::GetUrlForEvents(BSTR* url) { 448 if (NULL == url) 449 return E_POINTER; 450 *url = ::SysAllocString(url_); 451 return S_OK; 452 } 453 454 STDMETHODIMP ChromeActiveDocument::GetAddressBarUrl(BSTR* url) { 455 return GetUrlForEvents(url); 456 } 457 458 STDMETHODIMP ChromeActiveDocument::Reset() { 459 next_privacy_record_ = privacy_info_.privacy_records.begin(); 460 return S_OK; 461 } 462 463 STDMETHODIMP ChromeActiveDocument::GetSize(DWORD* size) { 464 if (!size) 465 return E_POINTER; 466 467 *size = privacy_info_.privacy_records.size(); 468 return S_OK; 469 } 470 471 STDMETHODIMP ChromeActiveDocument::GetPrivacyImpacted(BOOL* privacy_impacted) { 472 if (!privacy_impacted) 473 return E_POINTER; 474 475 *privacy_impacted = privacy_info_.privacy_impacted; 476 return S_OK; 477 } 478 479 STDMETHODIMP ChromeActiveDocument::Next(BSTR* url, BSTR* policy, 480 LONG* reserved, DWORD* flags) { 481 if (!url || !policy || !flags) 482 return E_POINTER; 483 484 if (next_privacy_record_ == privacy_info_.privacy_records.end()) 485 return HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS); 486 487 *url = SysAllocString(next_privacy_record_->first.c_str()); 488 *policy = SysAllocString(next_privacy_record_->second.policy_ref.c_str()); 489 *flags = next_privacy_record_->second.flags; 490 491 next_privacy_record_++; 492 return S_OK; 493 } 494 495 bool ChromeActiveDocument::IsSchemeAllowed(const GURL& url) { 496 bool allowed = BaseActiveX::IsSchemeAllowed(url); 497 if (allowed) 498 return true; 499 500 if (url.SchemeIs(chrome::kAboutScheme)) { 501 if (LowerCaseEqualsASCII(url.spec(), chrome::kAboutPluginsURL)) 502 return true; 503 } 504 return false; 505 } 506 507 HRESULT ChromeActiveDocument::GetInPlaceFrame( 508 IOleInPlaceFrame** in_place_frame) { 509 DCHECK(in_place_frame); 510 if (in_place_frame_) { 511 *in_place_frame = in_place_frame_.get(); 512 (*in_place_frame)->AddRef(); 513 return S_OK; 514 } else { 515 return S_FALSE; 516 } 517 } 518 519 HRESULT ChromeActiveDocument::IOleObject_SetClientSite( 520 IOleClientSite* client_site) { 521 if (client_site == NULL) { 522 base::win::ScopedComPtr<IDocHostUIHandler> doc_host_handler; 523 if (doc_site_) 524 doc_host_handler.QueryFrom(doc_site_); 525 526 if (doc_host_handler.get()) 527 doc_host_handler->HideUI(); 528 529 doc_site_.Release(); 530 } 531 532 if (client_site != m_spClientSite) 533 return BaseActiveX::IOleObject_SetClientSite(client_site); 534 535 return S_OK; 536 } 537 538 HRESULT ChromeActiveDocument::ActiveXDocActivate(LONG verb) { 539 HRESULT hr = S_OK; 540 m_bNegotiatedWnd = TRUE; 541 if (!m_bInPlaceActive) { 542 hr = m_spInPlaceSite->CanInPlaceActivate(); 543 if (FAILED(hr)) 544 return hr; 545 m_spInPlaceSite->OnInPlaceActivate(); 546 } 547 m_bInPlaceActive = TRUE; 548 // get location in the parent window, 549 // as well as some information about the parent 550 base::win::ScopedComPtr<IOleInPlaceUIWindow> in_place_ui_window; 551 frame_info_.cb = sizeof(OLEINPLACEFRAMEINFO); 552 HWND parent_window = NULL; 553 if (m_spInPlaceSite->GetWindow(&parent_window) == S_OK) { 554 in_place_frame_.Release(); 555 RECT position_rect = {0}; 556 RECT clip_rect = {0}; 557 m_spInPlaceSite->GetWindowContext(in_place_frame_.Receive(), 558 in_place_ui_window.Receive(), 559 &position_rect, 560 &clip_rect, 561 &frame_info_); 562 if (!m_bWndLess) { 563 if (IsWindow()) { 564 ::ShowWindow(m_hWnd, SW_SHOW); 565 SetFocus(); 566 } else { 567 m_hWnd = Create(parent_window, position_rect); 568 if (!IsWindow()) { 569 // This might happen if the automation server couldn't be 570 // instantiated. If so, a NOTREACHED() will have already been hit. 571 DLOG(ERROR) << "Failed to create Ax window"; 572 return AtlHresultFromLastError(); 573 } 574 } 575 } 576 SetObjectRects(&position_rect, &clip_rect); 577 } 578 579 base::win::ScopedComPtr<IOleInPlaceActiveObject> in_place_active_object(this); 580 581 // Gone active by now, take care of UIACTIVATE 582 if (DoesVerbUIActivate(verb)) { 583 if (!m_bUIActive) { 584 m_bUIActive = TRUE; 585 hr = m_spInPlaceSite->OnUIActivate(); 586 if (FAILED(hr)) 587 return hr; 588 // set ourselves up in the host 589 if (in_place_active_object) { 590 if (in_place_frame_) 591 in_place_frame_->SetActiveObject(in_place_active_object, NULL); 592 if (in_place_ui_window) 593 in_place_ui_window->SetActiveObject(in_place_active_object, NULL); 594 } 595 } 596 } 597 m_spClientSite->ShowObject(); 598 return S_OK; 599 } 600 601 void ChromeActiveDocument::OnNavigationStateChanged( 602 int flags, const NavigationInfo& nav_info) { 603 // TODO(joshia): handle INVALIDATE_TYPE_TAB,INVALIDATE_TYPE_LOAD etc. 604 DVLOG(1) << __FUNCTION__ 605 << "\n Flags: " << flags 606 << ", Url: " << nav_info.url 607 << ", Title: " << nav_info.title 608 << ", Type: " << nav_info.navigation_type 609 << ", Relative Offset: " << nav_info.relative_offset 610 << ", Index: " << nav_info.navigation_index; 611 612 UpdateNavigationState(nav_info, flags); 613 } 614 615 void ChromeActiveDocument::OnUpdateTargetUrl( 616 const std::wstring& new_target_url) { 617 if (in_place_frame_) 618 in_place_frame_->SetStatusText(new_target_url.c_str()); 619 } 620 621 bool IsFindAccelerator(const MSG& msg) { 622 // TODO(robertshield): This may not stand up to localization. Fix if this 623 // is the case. 624 return msg.message == WM_KEYDOWN && msg.wParam == 'F' && 625 base::win::IsCtrlPressed() && 626 !(base::win::IsAltPressed() || base::win::IsShiftPressed()); 627 } 628 629 void ChromeActiveDocument::OnAcceleratorPressed(const MSG& accel_message) { 630 if (::TranslateAccelerator(m_hWnd, accelerator_table_, 631 const_cast<MSG*>(&accel_message))) 632 return; 633 634 bool handled_accel = false; 635 if (in_place_frame_ != NULL) { 636 handled_accel = (S_OK == in_place_frame_->TranslateAcceleratorW( 637 const_cast<MSG*>(&accel_message), 0)); 638 } 639 640 if (!handled_accel) { 641 if (IsFindAccelerator(accel_message)) { 642 // Handle the showing of the find dialog explicitly. 643 OnFindInPage(); 644 } else { 645 BaseActiveX::OnAcceleratorPressed(accel_message); 646 } 647 } else { 648 DVLOG(1) << "IE handled accel key " << accel_message.wParam; 649 } 650 } 651 652 void ChromeActiveDocument::OnTabbedOut(bool reverse) { 653 DVLOG(1) << __FUNCTION__; 654 if (in_place_frame_) { 655 MSG msg = { NULL, WM_KEYDOWN, VK_TAB }; 656 in_place_frame_->TranslateAcceleratorW(&msg, 0); 657 } 658 } 659 660 void ChromeActiveDocument::OnDidNavigate(const NavigationInfo& nav_info) { 661 DVLOG(1) << __FUNCTION__ << std::endl 662 << "Url: " << nav_info.url 663 << ", Title: " << nav_info.title 664 << ", Type: " << nav_info.navigation_type 665 << ", Relative Offset: " << nav_info.relative_offset 666 << ", Index: " << nav_info.navigation_index; 667 668 CrashMetricsReporter::GetInstance()->IncrementMetric( 669 CrashMetricsReporter::CHROME_FRAME_NAVIGATION_COUNT); 670 671 UpdateNavigationState(nav_info, 0); 672 } 673 674 void ChromeActiveDocument::OnCloseTab() { 675 // Base class will fire DIChromeFrameEvents::onclose. 676 BaseActiveX::OnCloseTab(); 677 678 // Close the container window. 679 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 680 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 681 if (web_browser2) 682 web_browser2->Quit(); 683 } 684 685 void ChromeActiveDocument::UpdateNavigationState( 686 const NavigationInfo& new_navigation_info, int flags) { 687 // This could be NULL if the active document instance is being destroyed. 688 if (!m_spInPlaceSite) { 689 DVLOG(1) << __FUNCTION__ << "m_spInPlaceSite is NULL. Returning"; 690 return; 691 } 692 693 HRESULT hr = S_OK; 694 bool is_title_changed = 695 (navigation_info_->title != new_navigation_info.title); 696 bool is_ssl_state_changed = 697 (navigation_info_->security_style != 698 new_navigation_info.security_style) || 699 (navigation_info_->displayed_insecure_content != 700 new_navigation_info.displayed_insecure_content) || 701 (navigation_info_->ran_insecure_content != 702 new_navigation_info.ran_insecure_content); 703 704 if (is_ssl_state_changed) { 705 int lock_status = SECURELOCK_SET_UNSECURE; 706 switch (new_navigation_info.security_style) { 707 case content::SECURITY_STYLE_AUTHENTICATED: 708 lock_status = new_navigation_info.displayed_insecure_content ? 709 SECURELOCK_SET_MIXED : SECURELOCK_SET_SECUREUNKNOWNBIT; 710 break; 711 default: 712 break; 713 } 714 715 base::win::ScopedVariant secure_lock_status(lock_status); 716 IEExec(&CGID_ShellDocView, INTERNAL_CMDID_SET_SSL_LOCK, 717 OLECMDEXECOPT_DODEFAULT, secure_lock_status.AsInput(), NULL); 718 } 719 720 // A number of poorly written bho's crash in their event sink callbacks if 721 // chrome frame is the currently loaded document. This is because they expect 722 // chrome frame to implement interfaces like IHTMLDocument, etc. We patch the 723 // event sink's of these bho's and don't invoke the event sink if chrome 724 // frame is the currently loaded document. 725 if (GetConfigBool(true, kEnableBuggyBhoIntercept)) { 726 base::win::ScopedComPtr<IWebBrowser2> wb2; 727 DoQueryService(SID_SWebBrowserApp, m_spClientSite, wb2.Receive()); 728 if (wb2 && buggy_bho::BuggyBhoTls::GetInstance()) { 729 buggy_bho::BuggyBhoTls::GetInstance()->PatchBuggyBHOs(wb2); 730 } 731 } 732 733 // Ideally all navigations should come to Chrome Frame so that we can call 734 // BeforeNavigate2 on installed BHOs and give them a chance to cancel the 735 // navigation. However, in practice what happens is as below: 736 // The very first navigation that happens in CF happens via a Load or a 737 // LoadHistory call. In this case, IE already has the correct information for 738 // its travel log as well address bar. For other internal navigations (navs 739 // that only happen within Chrome such as anchor navigations) we need to 740 // update IE's internal state after the fact. In the case of internal 741 // navigations, we notify the BHOs but ignore the should_cancel flag. 742 743 // Another case where we need to issue BeforeNavigate2 calls is as below:- 744 // We get notified after the fact, when navigations are initiated within 745 // Chrome via window.open calls. These navigations are handled by creating 746 // an external tab container within chrome and then connecting to it from IE. 747 // We still want to update the address bar/history, etc, to ensure that 748 // the special URL used by Chrome to indicate this is updated correctly. 749 ChromeFrameUrl cf_url; 750 bool is_attach_external_tab_url = cf_url.Parse(std::wstring(url_)) && 751 cf_url.attach_to_external_tab(); 752 753 bool is_internal_navigation = 754 IsNewNavigation(new_navigation_info, flags) || is_attach_external_tab_url; 755 756 if (new_navigation_info.url.is_valid()) 757 url_.Allocate(UTF8ToWide(new_navigation_info.url.spec()).c_str()); 758 759 if (is_internal_navigation) { 760 // IE6 does not support tabs. If Chrome sent us a window open request 761 // indicating that the navigation needs to occur in a foreground tab or 762 // a popup window, then we need to ensure that the new window in IE6 is 763 // brought to the foreground. 764 if (GetIEVersion() == IE_6 && 765 is_attach_external_tab_url && 766 (cf_url.disposition() == NEW_FOREGROUND_TAB || 767 cf_url.disposition() == NEW_POPUP)) { 768 base::win::ScopedComPtr<IWebBrowser2> wb2; 769 DoQueryService(SID_SWebBrowserApp, m_spClientSite, wb2.Receive()); 770 if (wb2) 771 BaseActiveX::BringWebBrowserWindowToTop(wb2); 772 } 773 base::win::ScopedComPtr<IDocObjectService> doc_object_svc; 774 base::win::ScopedComPtr<IWebBrowserEventsService> web_browser_events_svc; 775 776 DoQueryService(__uuidof(web_browser_events_svc), m_spClientSite, 777 web_browser_events_svc.Receive()); 778 779 if (!web_browser_events_svc.get()) { 780 DoQueryService(SID_SShellBrowser, m_spClientSite, 781 doc_object_svc.Receive()); 782 } 783 784 // web_browser_events_svc can be NULL on IE6. 785 if (web_browser_events_svc) { 786 VARIANT_BOOL should_cancel = VARIANT_FALSE; 787 web_browser_events_svc->FireBeforeNavigate2Event(&should_cancel); 788 } else if (doc_object_svc) { 789 BOOL should_cancel = FALSE; 790 doc_object_svc->FireBeforeNavigate2(NULL, url_, 0, NULL, NULL, 0, 791 NULL, FALSE, &should_cancel); 792 } 793 794 // We need to tell IE that we support navigation so that IE will query us 795 // for IPersistHistory and call GetPositionCookie to save our navigation 796 // index. 797 base::win::ScopedVariant html_window(static_cast<IUnknown*>( 798 static_cast<IHTMLWindow2*>(this))); 799 IEExec(&CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, 800 html_window.AsInput(), NULL); 801 802 // We pass the HLNF_INTERNALJUMP flag to INTERNAL_CMDID_FINALIZE_TRAVEL_LOG 803 // since we want to make IE treat all internal navigations within this page 804 // (including anchor navigations and subframe navigations) as anchor 805 // navigations. This will ensure that IE calls GetPositionCookie 806 // to save the current position cookie in the travel log and then call 807 // SetPositionCookie when the user hits Back/Forward to come back here. 808 base::win::ScopedVariant internal_navigation(HLNF_INTERNALJUMP); 809 IEExec(&CGID_Explorer, INTERNAL_CMDID_FINALIZE_TRAVEL_LOG, 0, 810 internal_navigation.AsInput(), NULL); 811 812 // We no longer need to lie to IE. If we lie persistently to IE, then 813 // IE reuses us for new navigations. 814 IEExec(&CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, NULL, NULL); 815 816 if (doc_object_svc) { 817 // Now call the FireNavigateCompleteEvent which makes IE update the text 818 // in the address-bar. 819 doc_object_svc->FireNavigateComplete2(this, 0); 820 doc_object_svc->FireDocumentComplete(this, 0); 821 } else if (web_browser_events_svc) { 822 web_browser_events_svc->FireNavigateComplete2Event(); 823 web_browser_events_svc->FireDocumentCompleteEvent(); 824 } 825 } 826 827 if (is_title_changed) { 828 base::win::ScopedVariant title(new_navigation_info.title.c_str()); 829 IEExec(NULL, OLECMDID_SETTITLE, OLECMDEXECOPT_DONTPROMPTUSER, 830 title.AsInput(), NULL); 831 } 832 833 // There are cases in which we receive NavigationStateChanged events for 834 // provisional loads. These events will contain a new URL but will not be 835 // considered new navigations since their navigation_index is 0. For these 836 // events, do not update the navigation_info_ state, as this will muck up the 837 // travel log when the subsequent committed navigation event takes place. 838 // 839 // Given this filtering, also special-case first navigations since those 840 // are needed to initially populate navigation_info_ to keep it in sync with 841 // what was placed in the IE travel log when CF was first opened. 842 // 843 // Lastly, allow through navigation events that would neither affect the 844 // travel log nor cause the page location to change, as these will 845 // contain informational state (referrer, title, etc.) that we should 846 // preserve. 847 if (is_internal_navigation || IsFirstNavigation(new_navigation_info) || 848 new_navigation_info.url == navigation_info_->url) { 849 // It is important that we only update the navigation_info_ after we have 850 // finalized the travel log. This is because IE will ask for information 851 // such as navigation index when the travel log is finalized and we need 852 // supply the old index and not the new one. 853 *navigation_info_ = new_navigation_info; 854 } 855 856 // Update the IE zone here. Ideally we would like to do it when the active 857 // document is activated. However that does not work at times as the frame we 858 // get there is not the actual frame which handles the command. 859 IEExec(&CGID_Explorer, SBCMDID_MIXEDZONE, 0, NULL, NULL); 860 } 861 862 void ChromeActiveDocument::OnFindInPage() { 863 TabProxy* tab = GetTabProxy(); 864 if (tab) { 865 if (!find_dialog_.IsWindow()) 866 find_dialog_.Create(m_hWnd); 867 868 find_dialog_.ShowWindow(SW_SHOW); 869 } 870 } 871 872 void ChromeActiveDocument::OnViewSource() { 873 DCHECK(navigation_info_->url.is_valid()); 874 HostNavigate(GURL(content::kViewSourceScheme + std::string(":") + 875 navigation_info_->url.spec()), GURL(), NEW_WINDOW); 876 } 877 878 void ChromeActiveDocument::OnDetermineSecurityZone(const GUID* cmd_group_guid, 879 DWORD command_id, 880 DWORD cmd_exec_opt, 881 VARIANT* in_args, 882 VARIANT* out_args) { 883 // Always return URLZONE_INTERNET since that is the Chrome's behaviour. 884 // Correct step is to use MapUrlToZone(). 885 if (out_args != NULL) { 886 out_args->vt = VT_UI4; 887 out_args->ulVal = URLZONE_INTERNET; 888 } 889 } 890 891 void ChromeActiveDocument::OnDisplayPrivacyInfo() { 892 privacy_info_ = url_fetcher_->privacy_info(); 893 Reset(); 894 DoPrivacyDlg(m_hWnd, url_, this, TRUE); 895 } 896 897 void ChromeActiveDocument::OnGetZoomRange(const GUID* cmd_group_guid, 898 DWORD command_id, 899 DWORD cmd_exec_opt, 900 VARIANT* in_args, 901 VARIANT* out_args) { 902 if (out_args != NULL) { 903 out_args->vt = VT_I4; 904 out_args->lVal = 0; 905 } 906 } 907 908 void ChromeActiveDocument::OnSetZoomRange(const GUID* cmd_group_guid, 909 DWORD command_id, 910 DWORD cmd_exec_opt, 911 VARIANT* in_args, 912 VARIANT* out_args) { 913 const int kZoomIn = 125; 914 const int kZoomOut = 75; 915 916 if (in_args && V_VT(in_args) == VT_I4 && IsValid()) { 917 if (in_args->lVal == kZoomIn) { 918 automation_client_->SetZoomLevel(content::PAGE_ZOOM_IN); 919 } else if (in_args->lVal == kZoomOut) { 920 automation_client_->SetZoomLevel(content::PAGE_ZOOM_OUT); 921 } else { 922 DLOG(WARNING) << "Unsupported zoom level:" << in_args->lVal; 923 } 924 } 925 } 926 927 void ChromeActiveDocument::OnUnload(const GUID* cmd_group_guid, 928 DWORD command_id, 929 DWORD cmd_exec_opt, 930 VARIANT* in_args, 931 VARIANT* out_args) { 932 if (IsValid() && out_args) { 933 // If the navigation is attempted to the url loaded in CF, with the only 934 // difference being the addition of an anchor, IE will attempt to unload 935 // the currently loaded document which basically would end up running 936 // unload handlers on the currently loaded document thus rendering it non 937 // functional. We handle this as below:- 938 // The BHO receives the new url in the BeforeNavigate event. 939 // We compare the non anchor portions of the url in the BHO with the loaded 940 // url and if they match, we initiate a Chrome navigation to the url with 941 // the anchor which works nicely. 942 // We don't want to continue processing the unload in this case. 943 // Note:- 944 // IE handles these navigations by querying the loaded document for 945 // IHTMLDocument which then handles the new navigation. That won't work for 946 // us as we don't implement IHTMLDocument. 947 NavigationManager* mgr = NavigationManager::GetThreadInstance(); 948 DLOG_IF(ERROR, !mgr) << "Couldn't get instance of NavigationManager"; 949 if (mgr) { 950 ChromeFrameUrl url; 951 url.Parse(mgr->url()); 952 if (url.gurl().has_ref()) { 953 url_canon::Replacements<char> replacements; 954 replacements.ClearRef(); 955 956 if (url.gurl().ReplaceComponents(replacements) == 957 GURL(static_cast<BSTR>(url_))) { 958 // We want to reuse the existing automation client and channel for 959 // initiating the new navigation. Setting the 960 // is_automation_client_reused_ flag to true before calling the 961 // LaunchUrl function achieves that. 962 is_automation_client_reused_ = true; 963 LaunchUrl(url, mgr->referrer()); 964 out_args->vt = VT_BOOL; 965 out_args->boolVal = VARIANT_FALSE; 966 return; 967 } 968 } 969 } 970 bool should_unload = true; 971 automation_client_->OnUnload(&should_unload); 972 out_args->vt = VT_BOOL; 973 out_args->boolVal = should_unload ? VARIANT_TRUE : VARIANT_FALSE; 974 } 975 } 976 977 void ChromeActiveDocument::OnAttachExternalTab( 978 const AttachExternalTabParams& params) { 979 if (!automation_client_.get()) { 980 DLOG(WARNING) << "Invalid automation client instance"; 981 return; 982 } 983 DWORD flags = 0; 984 if (params.user_gesture) 985 flags = NWMF_USERREQUESTED; 986 else if (popup_allowed_) 987 flags = NWMF_USERALLOWED; 988 989 HRESULT hr = S_OK; 990 if (popup_manager_) { 991 const std::wstring& url_wide = UTF8ToWide(params.url.spec()); 992 hr = popup_manager_->EvaluateNewWindow(url_wide.c_str(), NULL, url_, 993 NULL, FALSE, flags, 0); 994 } 995 // Allow popup 996 if (hr == S_OK) { 997 BaseActiveX::OnAttachExternalTab(params); 998 return; 999 } 1000 1001 automation_client_->BlockExternalTab(params.cookie); 1002 } 1003 1004 bool ChromeActiveDocument::PreProcessContextMenu(HMENU menu) { 1005 base::win::ScopedComPtr<IBrowserService> browser_service; 1006 base::win::ScopedComPtr<ITravelLog> travel_log; 1007 GetBrowserServiceAndTravelLog(browser_service.Receive(), 1008 travel_log.Receive()); 1009 if (!browser_service || !travel_log) 1010 return true; 1011 1012 EnableMenuItem(menu, IDC_BACK, MF_BYCOMMAND | 1013 (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_BACK, 1014 NULL)) ? 1015 MF_ENABLED : MF_DISABLED)); 1016 EnableMenuItem(menu, IDC_FORWARD, MF_BYCOMMAND | 1017 (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_FORE, 1018 NULL)) ? 1019 MF_ENABLED : MF_DISABLED)); 1020 // Call base class (adds 'About' item) 1021 return BaseActiveX::PreProcessContextMenu(menu); 1022 } 1023 1024 bool ChromeActiveDocument::HandleContextMenuCommand( 1025 UINT cmd, const MiniContextMenuParams& params) { 1026 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1027 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 1028 1029 if (cmd == IDC_BACK) 1030 web_browser2->GoBack(); 1031 else if (cmd == IDC_FORWARD) 1032 web_browser2->GoForward(); 1033 else if (cmd == IDC_RELOAD) 1034 web_browser2->Refresh(); 1035 else 1036 return BaseActiveX::HandleContextMenuCommand(cmd, params); 1037 1038 return true; 1039 } 1040 1041 HRESULT ChromeActiveDocument::IEExec(const GUID* cmd_group_guid, 1042 DWORD command_id, DWORD cmd_exec_opt, 1043 VARIANT* in_args, VARIANT* out_args) { 1044 HRESULT hr = E_FAIL; 1045 1046 base::win::ScopedComPtr<IOleCommandTarget> frame_cmd_target; 1047 1048 base::win::ScopedComPtr<IOleInPlaceSite> in_place_site(m_spInPlaceSite); 1049 if (!in_place_site.get() && m_spClientSite != NULL) 1050 in_place_site.QueryFrom(m_spClientSite); 1051 1052 if (in_place_site) 1053 hr = frame_cmd_target.QueryFrom(in_place_site); 1054 1055 if (frame_cmd_target) { 1056 hr = frame_cmd_target->Exec(cmd_group_guid, command_id, cmd_exec_opt, 1057 in_args, out_args); 1058 } 1059 1060 return hr; 1061 } 1062 1063 bool ChromeActiveDocument::LaunchUrl(const ChromeFrameUrl& cf_url, 1064 const std::string& referrer) { 1065 DCHECK(!cf_url.gurl().is_empty()); 1066 1067 if (!automation_client_.get()) { 1068 // http://code.google.com/p/chromium/issues/detail?id=52894 1069 // Still not sure how this happens. 1070 DLOG(ERROR) << "No automation client!"; 1071 if (!Initialize()) { 1072 NOTREACHED() << "...and failed to start a new one >:("; 1073 return false; 1074 } 1075 } 1076 1077 document_url_ = cf_url.gurl().spec(); 1078 1079 url_.Allocate(UTF8ToWide(cf_url.gurl().spec()).c_str()); 1080 if (cf_url.attach_to_external_tab()) { 1081 automation_client_->AttachExternalTab(cf_url.cookie()); 1082 OnMoveWindow(cf_url.dimensions()); 1083 } else if (!automation_client_->InitiateNavigation(cf_url.gurl().spec(), 1084 referrer, 1085 this)) { 1086 DLOG(ERROR) << "Invalid URL: " << url_; 1087 Error(L"Invalid URL"); 1088 url_.Reset(); 1089 return false; 1090 } 1091 1092 if (is_automation_client_reused_) 1093 return true; 1094 1095 automation_client_->SetUrlFetcher(url_fetcher_.get()); 1096 if (launch_params_) { 1097 return automation_client_->Initialize(this, launch_params_); 1098 } else { 1099 std::wstring profile = UTF8ToWide(cf_url.profile_name()); 1100 // If no profile was given, then make use of the host process's name. 1101 if (profile.empty()) 1102 profile = GetHostProcessName(false); 1103 return InitializeAutomation(profile, IsIEInPrivate(), 1104 false, cf_url.gurl(), GURL(referrer), 1105 false); 1106 } 1107 } 1108 1109 HRESULT ChromeActiveDocument::OnRefreshPage(const GUID* cmd_group_guid, 1110 DWORD command_id, DWORD cmd_exec_opt, VARIANT* in_args, VARIANT* out_args) { 1111 DVLOG(1) << __FUNCTION__; 1112 popup_allowed_ = false; 1113 if (in_args->vt == VT_I4 && 1114 in_args->lVal & OLECMDIDF_REFRESH_PAGEACTION_POPUPWINDOW) { 1115 popup_allowed_ = true; 1116 1117 // Ask the yellow security band to change the text and icon and to remain 1118 // visible. 1119 IEExec(&CGID_DocHostCommandHandler, OLECMDID_PAGEACTIONBLOCKED, 1120 0x80000000 | OLECMDIDF_WINDOWSTATE_USERVISIBLE_VALID, NULL, NULL); 1121 } 1122 1123 NavigationManager* mgr = NavigationManager::GetThreadInstance(); 1124 DLOG_IF(ERROR, !mgr) << "Couldn't get instance of NavigationManager"; 1125 1126 // If ChromeFrame was activated on this page as a result of a document 1127 // received in response to a top level post, then we ask the user for 1128 // permission to repost and issue a navigation with the saved post data 1129 // which reinitates the whole sequence, i.e. the server receives the top 1130 // level post and chrome frame will be reactivated in response. 1131 if (mgr && mgr->post_data().type() != VT_EMPTY) { 1132 if (MessageBox( 1133 SimpleResourceLoader::Get(IDS_HTTP_POST_WARNING).c_str(), 1134 SimpleResourceLoader::Get(IDS_HTTP_POST_WARNING_TITLE).c_str(), 1135 MB_YESNO | MB_ICONEXCLAMATION) == IDYES) { 1136 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1137 DoQueryService(SID_SWebBrowserApp, m_spClientSite, 1138 web_browser2.Receive()); 1139 DCHECK(web_browser2); 1140 VARIANT empty = base::win::ScopedVariant::kEmptyVariant; 1141 VARIANT flags = { VT_I4 }; 1142 V_I4(&flags) = navNoHistory; 1143 1144 return web_browser2->Navigate2(base::win::ScopedVariant(url_).AsInput(), 1145 &flags, 1146 &empty, 1147 const_cast<VARIANT*>(&mgr->post_data()), 1148 const_cast<VARIANT*>(&mgr->headers())); 1149 } else { 1150 return S_OK; 1151 } 1152 } 1153 1154 TabProxy* tab_proxy = GetTabProxy(); 1155 if (tab_proxy) { 1156 tab_proxy->ReloadAsync(); 1157 } else { 1158 DLOG(ERROR) << "No automation proxy"; 1159 DCHECK(automation_client_.get() != NULL) << "how did it get freed?"; 1160 // The current url request manager (url_fetcher_) has been switched to 1161 // a stopping state so we need to reset it and get a new one for the new 1162 // automation server. 1163 ResetUrlRequestManager(); 1164 url_fetcher_->set_frame_busting(false); 1165 // And now launch the current URL again. This starts a new server process. 1166 DCHECK(navigation_info_->url.is_valid()); 1167 ChromeFrameUrl cf_url; 1168 cf_url.Parse(UTF8ToWide(navigation_info_->url.spec())); 1169 LaunchUrl(cf_url, navigation_info_->referrer.spec()); 1170 } 1171 1172 return S_OK; 1173 } 1174 1175 HRESULT ChromeActiveDocument::SetPageFontSize(const GUID* cmd_group_guid, 1176 DWORD command_id, 1177 DWORD cmd_exec_opt, 1178 VARIANT* in_args, 1179 VARIANT* out_args) { 1180 if (!automation_client_.get()) { 1181 NOTREACHED() << "Invalid automation client"; 1182 return E_FAIL; 1183 } 1184 1185 switch (command_id) { 1186 case IDM_BASELINEFONT1: 1187 automation_client_->SetPageFontSize(SMALLEST_FONT); 1188 break; 1189 1190 case IDM_BASELINEFONT2: 1191 automation_client_->SetPageFontSize(SMALL_FONT); 1192 break; 1193 1194 case IDM_BASELINEFONT3: 1195 automation_client_->SetPageFontSize(MEDIUM_FONT); 1196 break; 1197 1198 case IDM_BASELINEFONT4: 1199 automation_client_->SetPageFontSize(LARGE_FONT); 1200 break; 1201 1202 case IDM_BASELINEFONT5: 1203 automation_client_->SetPageFontSize(LARGEST_FONT); 1204 break; 1205 1206 default: 1207 NOTREACHED() << "Invalid font size command: " 1208 << command_id; 1209 return E_FAIL; 1210 } 1211 1212 // Forward the command back to IEFrame with group set to 1213 // CGID_ExplorerBarDoc. This is probably needed to update the menu state to 1214 // indicate that the font size was set. This currently fails with error 1215 // 0x80040104. 1216 // TODO(iyengar) 1217 // Do some investigation into why this Exec call fails. 1218 IEExec(&CGID_ExplorerBarDoc, command_id, cmd_exec_opt, NULL, NULL); 1219 return S_OK; 1220 } 1221 1222 HRESULT ChromeActiveDocument::OnEncodingChange(const GUID* cmd_group_guid, 1223 DWORD command_id, 1224 DWORD cmd_exec_opt, 1225 VARIANT* in_args, 1226 VARIANT* out_args) { 1227 const struct EncodingMapData { 1228 DWORD ie_encoding_id; 1229 const char* chrome_encoding_name; 1230 } kEncodingTestDatas[] = { 1231 #define DEFINE_ENCODING_MAP(encoding_name, id, chrome_name) \ 1232 { encoding_name, chrome_name }, 1233 INTERNAL_IE_ENCODINGMENU_IDS(DEFINE_ENCODING_MAP) 1234 #undef DEFINE_ENCODING_MAP 1235 }; 1236 1237 if (!automation_client_.get()) { 1238 NOTREACHED() << "Invalid automtion client"; 1239 return E_FAIL; 1240 } 1241 1242 // Using ARRAYSIZE_UNSAFE in here is because we define the struct 1243 // EncodingMapData inside function. 1244 const char* chrome_encoding_name = NULL; 1245 for (int i = 0; i < ARRAYSIZE_UNSAFE(kEncodingTestDatas); ++i) { 1246 const struct EncodingMapData* encoding_data = &kEncodingTestDatas[i]; 1247 if (command_id == encoding_data->ie_encoding_id) { 1248 chrome_encoding_name = encoding_data->chrome_encoding_name; 1249 break; 1250 } 1251 } 1252 // Return E_FAIL when encountering invalid encoding id. 1253 if (!chrome_encoding_name) 1254 return E_FAIL; 1255 1256 TabProxy* tab = GetTabProxy(); 1257 if (!tab) { 1258 NOTREACHED() << "Can not get TabProxy"; 1259 return E_FAIL; 1260 } 1261 1262 if (chrome_encoding_name) 1263 tab->OverrideEncoding(chrome_encoding_name); 1264 1265 // Like we did on SetPageFontSize, we may forward the command back to IEFrame 1266 // to update the menu state to indicate that which encoding was set. 1267 // TODO(iyengar) 1268 // Do some investigation into why this Exec call fails. 1269 IEExec(&CGID_ExplorerBarDoc, command_id, cmd_exec_opt, NULL, NULL); 1270 return S_OK; 1271 } 1272 1273 void ChromeActiveDocument::OnGoToHistoryEntryOffset(int offset) { 1274 DVLOG(1) << __FUNCTION__ << " - offset:" << offset; 1275 1276 base::win::ScopedComPtr<IBrowserService> browser_service; 1277 base::win::ScopedComPtr<ITravelLog> travel_log; 1278 GetBrowserServiceAndTravelLog(browser_service.Receive(), 1279 travel_log.Receive()); 1280 1281 if (browser_service && travel_log) 1282 travel_log->Travel(browser_service, offset); 1283 } 1284 1285 void ChromeActiveDocument::OnMoveWindow(const gfx::Rect& dimensions) { 1286 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1287 DoQueryService(SID_SWebBrowserApp, m_spClientSite, 1288 web_browser2.Receive()); 1289 if (!web_browser2) 1290 return; 1291 DVLOG(1) << "this:" << this << "\ndimensions: width:" << dimensions.width() 1292 << " height:" << dimensions.height(); 1293 if (!dimensions.IsEmpty()) { 1294 web_browser2->put_MenuBar(VARIANT_FALSE); 1295 web_browser2->put_ToolBar(VARIANT_FALSE); 1296 1297 int width = dimensions.width(); 1298 int height = dimensions.height(); 1299 // Compute the size of the browser window given the desired size of the 1300 // content area. As per MSDN, the WebBrowser object returns an error from 1301 // this method. As a result the code below is best effort. 1302 web_browser2->ClientToWindow(&width, &height); 1303 1304 web_browser2->put_Width(width); 1305 web_browser2->put_Height(height); 1306 web_browser2->put_Left(dimensions.x()); 1307 web_browser2->put_Top(dimensions.y()); 1308 } 1309 } 1310 1311 HRESULT ChromeActiveDocument::GetBrowserServiceAndTravelLog( 1312 IBrowserService** browser_service, ITravelLog** travel_log) { 1313 DCHECK(browser_service || travel_log); 1314 base::win::ScopedComPtr<IBrowserService> browser_service_local; 1315 HRESULT hr = DoQueryService(SID_SShellBrowser, m_spClientSite, 1316 browser_service_local.Receive()); 1317 if (!browser_service_local) { 1318 NOTREACHED() << "DoQueryService for IBrowserService failed: " << hr; 1319 return hr; 1320 } 1321 1322 if (travel_log) { 1323 hr = browser_service_local->GetTravelLog(travel_log); 1324 DVLOG_IF(1, !travel_log) << "browser_service->GetTravelLog failed: " << hr; 1325 } 1326 1327 if (browser_service) 1328 *browser_service = browser_service_local.Detach(); 1329 1330 return hr; 1331 } 1332 1333 LRESULT ChromeActiveDocument::OnForward(WORD notify_code, WORD id, 1334 HWND control_window, 1335 BOOL& bHandled) { 1336 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1337 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 1338 DCHECK(web_browser2); 1339 1340 if (web_browser2) 1341 web_browser2->GoForward(); 1342 return 0; 1343 } 1344 1345 LRESULT ChromeActiveDocument::OnBack(WORD notify_code, WORD id, 1346 HWND control_window, 1347 BOOL& bHandled) { 1348 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1349 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 1350 DCHECK(web_browser2); 1351 1352 if (web_browser2) 1353 web_browser2->GoBack(); 1354 return 0; 1355 } 1356 1357 LRESULT ChromeActiveDocument::OnFirePrivacyChange(UINT message, WPARAM wparam, 1358 LPARAM lparam, 1359 BOOL& handled) { 1360 if (!m_spClientSite) 1361 return 0; 1362 1363 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1364 DoQueryService(SID_SWebBrowserApp, m_spClientSite, 1365 web_browser2.Receive()); 1366 if (!web_browser2) { 1367 NOTREACHED() << "Failed to retrieve IWebBrowser2 interface."; 1368 return 0; 1369 } 1370 1371 base::win::ScopedComPtr<IShellBrowser> shell_browser; 1372 DoQueryService(SID_STopLevelBrowser, web_browser2, 1373 shell_browser.Receive()); 1374 DCHECK(shell_browser.get() != NULL); 1375 base::win::ScopedComPtr<ITridentService2> trident_services; 1376 trident_services.QueryFrom(shell_browser); 1377 if (trident_services) 1378 trident_services->FirePrivacyImpactedStateChange(wparam); 1379 else 1380 NOTREACHED() << "Failed to retrieve IWebBrowser2 interface."; 1381 return 0; 1382 } 1383 1384 LRESULT ChromeActiveDocument::OnShowWindow(UINT message, WPARAM wparam, 1385 LPARAM lparam, 1386 BOOL& handled) { // NO_LINT 1387 if (wparam) 1388 SetFocus(); 1389 return 0; 1390 } 1391 1392 LRESULT ChromeActiveDocument::OnSetFocus(UINT message, WPARAM wparam, 1393 LPARAM lparam, 1394 BOOL& handled) { // NO_LINT 1395 if (!ignore_setfocus_) 1396 GiveFocusToChrome(false); 1397 return 0; 1398 } 1399 1400 bool ChromeActiveDocument::IsNewNavigation( 1401 const NavigationInfo& new_navigation_info, int flags) const { 1402 // A new navigation is typically an internal navigation which is initiated by 1403 // the renderer(WebKit). Condition 1 below has to be true along with the 1404 // any of the other conditions below. 1405 // 1. The navigation notification flags passed in as the flags parameter 1406 // is not INVALIDATE_TYPE_LOAD which indicates that the loading state of 1407 // the tab changed. 1408 // 2. The navigation index is greater than 0 which means that a top level 1409 // navigation was initiated on the current external tab. 1410 // 3. The navigation type has changed. 1411 // 4. The url or the referrer are different. 1412 if (flags == content::INVALIDATE_TYPE_LOAD) 1413 return false; 1414 1415 if (new_navigation_info.navigation_index <= 0) 1416 return false; 1417 1418 if (new_navigation_info.navigation_index == 1419 navigation_info_->navigation_index) 1420 return false; 1421 1422 if (new_navigation_info.navigation_type != navigation_info_->navigation_type) 1423 return true; 1424 1425 if (new_navigation_info.url != navigation_info_->url) 1426 return true; 1427 1428 if (new_navigation_info.referrer != navigation_info_->referrer) 1429 return true; 1430 1431 return false; 1432 } 1433 1434 bool ChromeActiveDocument::IsFirstNavigation( 1435 const NavigationInfo& new_navigation_info) const { 1436 return (navigation_info_->url.is_empty() && 1437 new_navigation_info.navigation_type == 1438 content::NAVIGATION_TYPE_NEW_PAGE); 1439 } 1440
