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() : EmptyString()); 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 const std::string& referrer = EmptyString(); 403 if (!LaunchUrl(cf_url, referrer)) { 404 NOTREACHED() << __FUNCTION__ << " Failed to launch url:" << url; 405 return E_INVALIDARG; 406 } 407 return S_OK; 408 } 409 410 STDMETHODIMP ChromeActiveDocument::SaveHistory(IStream* stream) { 411 // TODO(sanjeevr): We need to fetch the entire list of navigation entries 412 // from Chrome and persist it in the stream. And in LoadHistory we need to 413 // pass this list back to Chrome which will recreate the list. This will allow 414 // Back-Forward navigation to anchors to work correctly when we navigate to a 415 // page outside of ChromeFrame and then come back. 416 if (!stream) { 417 NOTREACHED(); 418 return E_INVALIDARG; 419 } 420 421 LARGE_INTEGER offset = {0}; 422 ULARGE_INTEGER new_pos = {0}; 423 DWORD written = 0; 424 std::wstring url = UTF8ToWide(navigation_info_->url.spec()); 425 return stream->Write(url.c_str(), (url.length() + 1) * sizeof(wchar_t), 426 &written); 427 } 428 429 STDMETHODIMP ChromeActiveDocument::SetPositionCookie(DWORD position_cookie) { 430 if (automation_client_.get()) { 431 int index = static_cast<int>(position_cookie); 432 navigation_info_->navigation_index = index; 433 automation_client_->NavigateToIndex(index); 434 } else { 435 DLOG(WARNING) << "Invalid automation client instance"; 436 } 437 return S_OK; 438 } 439 440 STDMETHODIMP ChromeActiveDocument::GetPositionCookie(DWORD* position_cookie) { 441 if (!position_cookie) 442 return E_INVALIDARG; 443 444 *position_cookie = navigation_info_->navigation_index; 445 return S_OK; 446 } 447 448 STDMETHODIMP ChromeActiveDocument::GetUrlForEvents(BSTR* url) { 449 if (NULL == url) 450 return E_POINTER; 451 *url = ::SysAllocString(url_); 452 return S_OK; 453 } 454 455 STDMETHODIMP ChromeActiveDocument::GetAddressBarUrl(BSTR* url) { 456 return GetUrlForEvents(url); 457 } 458 459 STDMETHODIMP ChromeActiveDocument::Reset() { 460 next_privacy_record_ = privacy_info_.privacy_records.begin(); 461 return S_OK; 462 } 463 464 STDMETHODIMP ChromeActiveDocument::GetSize(DWORD* size) { 465 if (!size) 466 return E_POINTER; 467 468 *size = privacy_info_.privacy_records.size(); 469 return S_OK; 470 } 471 472 STDMETHODIMP ChromeActiveDocument::GetPrivacyImpacted(BOOL* privacy_impacted) { 473 if (!privacy_impacted) 474 return E_POINTER; 475 476 *privacy_impacted = privacy_info_.privacy_impacted; 477 return S_OK; 478 } 479 480 STDMETHODIMP ChromeActiveDocument::Next(BSTR* url, BSTR* policy, 481 LONG* reserved, DWORD* flags) { 482 if (!url || !policy || !flags) 483 return E_POINTER; 484 485 if (next_privacy_record_ == privacy_info_.privacy_records.end()) 486 return HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS); 487 488 *url = SysAllocString(next_privacy_record_->first.c_str()); 489 *policy = SysAllocString(next_privacy_record_->second.policy_ref.c_str()); 490 *flags = next_privacy_record_->second.flags; 491 492 next_privacy_record_++; 493 return S_OK; 494 } 495 496 bool ChromeActiveDocument::IsSchemeAllowed(const GURL& url) { 497 bool allowed = BaseActiveX::IsSchemeAllowed(url); 498 if (allowed) 499 return true; 500 501 if (url.SchemeIs(chrome::kAboutScheme)) { 502 if (LowerCaseEqualsASCII(url.spec(), chrome::kAboutPluginsURL)) 503 return true; 504 } 505 return false; 506 } 507 508 HRESULT ChromeActiveDocument::GetInPlaceFrame( 509 IOleInPlaceFrame** in_place_frame) { 510 DCHECK(in_place_frame); 511 if (in_place_frame_) { 512 *in_place_frame = in_place_frame_.get(); 513 (*in_place_frame)->AddRef(); 514 return S_OK; 515 } else { 516 return S_FALSE; 517 } 518 } 519 520 HRESULT ChromeActiveDocument::IOleObject_SetClientSite( 521 IOleClientSite* client_site) { 522 if (client_site == NULL) { 523 base::win::ScopedComPtr<IDocHostUIHandler> doc_host_handler; 524 if (doc_site_) 525 doc_host_handler.QueryFrom(doc_site_); 526 527 if (doc_host_handler.get()) 528 doc_host_handler->HideUI(); 529 530 doc_site_.Release(); 531 } 532 533 if (client_site != m_spClientSite) 534 return BaseActiveX::IOleObject_SetClientSite(client_site); 535 536 return S_OK; 537 } 538 539 HRESULT ChromeActiveDocument::ActiveXDocActivate(LONG verb) { 540 HRESULT hr = S_OK; 541 m_bNegotiatedWnd = TRUE; 542 if (!m_bInPlaceActive) { 543 hr = m_spInPlaceSite->CanInPlaceActivate(); 544 if (FAILED(hr)) 545 return hr; 546 m_spInPlaceSite->OnInPlaceActivate(); 547 } 548 m_bInPlaceActive = TRUE; 549 // get location in the parent window, 550 // as well as some information about the parent 551 base::win::ScopedComPtr<IOleInPlaceUIWindow> in_place_ui_window; 552 frame_info_.cb = sizeof(OLEINPLACEFRAMEINFO); 553 HWND parent_window = NULL; 554 if (m_spInPlaceSite->GetWindow(&parent_window) == S_OK) { 555 in_place_frame_.Release(); 556 RECT position_rect = {0}; 557 RECT clip_rect = {0}; 558 m_spInPlaceSite->GetWindowContext(in_place_frame_.Receive(), 559 in_place_ui_window.Receive(), 560 &position_rect, 561 &clip_rect, 562 &frame_info_); 563 if (!m_bWndLess) { 564 if (IsWindow()) { 565 ::ShowWindow(m_hWnd, SW_SHOW); 566 SetFocus(); 567 } else { 568 m_hWnd = Create(parent_window, position_rect); 569 if (!IsWindow()) { 570 // This might happen if the automation server couldn't be 571 // instantiated. If so, a NOTREACHED() will have already been hit. 572 DLOG(ERROR) << "Failed to create Ax window"; 573 return AtlHresultFromLastError(); 574 } 575 } 576 } 577 SetObjectRects(&position_rect, &clip_rect); 578 } 579 580 base::win::ScopedComPtr<IOleInPlaceActiveObject> in_place_active_object(this); 581 582 // Gone active by now, take care of UIACTIVATE 583 if (DoesVerbUIActivate(verb)) { 584 if (!m_bUIActive) { 585 m_bUIActive = TRUE; 586 hr = m_spInPlaceSite->OnUIActivate(); 587 if (FAILED(hr)) 588 return hr; 589 // set ourselves up in the host 590 if (in_place_active_object) { 591 if (in_place_frame_) 592 in_place_frame_->SetActiveObject(in_place_active_object, NULL); 593 if (in_place_ui_window) 594 in_place_ui_window->SetActiveObject(in_place_active_object, NULL); 595 } 596 } 597 } 598 m_spClientSite->ShowObject(); 599 return S_OK; 600 } 601 602 void ChromeActiveDocument::OnNavigationStateChanged( 603 int flags, const NavigationInfo& nav_info) { 604 // TODO(joshia): handle INVALIDATE_TYPE_TAB,INVALIDATE_TYPE_LOAD etc. 605 DVLOG(1) << __FUNCTION__ 606 << "\n Flags: " << flags 607 << ", Url: " << nav_info.url 608 << ", Title: " << nav_info.title 609 << ", Type: " << nav_info.navigation_type 610 << ", Relative Offset: " << nav_info.relative_offset 611 << ", Index: " << nav_info.navigation_index; 612 613 UpdateNavigationState(nav_info, flags); 614 } 615 616 void ChromeActiveDocument::OnUpdateTargetUrl( 617 const std::wstring& new_target_url) { 618 if (in_place_frame_) 619 in_place_frame_->SetStatusText(new_target_url.c_str()); 620 } 621 622 bool IsFindAccelerator(const MSG& msg) { 623 // TODO(robertshield): This may not stand up to localization. Fix if this 624 // is the case. 625 return msg.message == WM_KEYDOWN && msg.wParam == 'F' && 626 base::win::IsCtrlPressed() && 627 !(base::win::IsAltPressed() || base::win::IsShiftPressed()); 628 } 629 630 void ChromeActiveDocument::OnAcceleratorPressed(const MSG& accel_message) { 631 if (::TranslateAccelerator(m_hWnd, accelerator_table_, 632 const_cast<MSG*>(&accel_message))) 633 return; 634 635 bool handled_accel = false; 636 if (in_place_frame_ != NULL) { 637 handled_accel = (S_OK == in_place_frame_->TranslateAcceleratorW( 638 const_cast<MSG*>(&accel_message), 0)); 639 } 640 641 if (!handled_accel) { 642 if (IsFindAccelerator(accel_message)) { 643 // Handle the showing of the find dialog explicitly. 644 OnFindInPage(); 645 } else { 646 BaseActiveX::OnAcceleratorPressed(accel_message); 647 } 648 } else { 649 DVLOG(1) << "IE handled accel key " << accel_message.wParam; 650 } 651 } 652 653 void ChromeActiveDocument::OnTabbedOut(bool reverse) { 654 DVLOG(1) << __FUNCTION__; 655 if (in_place_frame_) { 656 MSG msg = { NULL, WM_KEYDOWN, VK_TAB }; 657 in_place_frame_->TranslateAcceleratorW(&msg, 0); 658 } 659 } 660 661 void ChromeActiveDocument::OnDidNavigate(const NavigationInfo& nav_info) { 662 DVLOG(1) << __FUNCTION__ << std::endl 663 << "Url: " << nav_info.url 664 << ", Title: " << nav_info.title 665 << ", Type: " << nav_info.navigation_type 666 << ", Relative Offset: " << nav_info.relative_offset 667 << ", Index: " << nav_info.navigation_index; 668 669 CrashMetricsReporter::GetInstance()->IncrementMetric( 670 CrashMetricsReporter::CHROME_FRAME_NAVIGATION_COUNT); 671 672 UpdateNavigationState(nav_info, 0); 673 } 674 675 void ChromeActiveDocument::OnCloseTab() { 676 // Base class will fire DIChromeFrameEvents::onclose. 677 BaseActiveX::OnCloseTab(); 678 679 // Close the container window. 680 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 681 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 682 if (web_browser2) 683 web_browser2->Quit(); 684 } 685 686 void ChromeActiveDocument::UpdateNavigationState( 687 const NavigationInfo& new_navigation_info, int flags) { 688 // This could be NULL if the active document instance is being destroyed. 689 if (!m_spInPlaceSite) { 690 DVLOG(1) << __FUNCTION__ << "m_spInPlaceSite is NULL. Returning"; 691 return; 692 } 693 694 HRESULT hr = S_OK; 695 bool is_title_changed = 696 (navigation_info_->title != new_navigation_info.title); 697 bool is_ssl_state_changed = 698 (navigation_info_->security_style != 699 new_navigation_info.security_style) || 700 (navigation_info_->displayed_insecure_content != 701 new_navigation_info.displayed_insecure_content) || 702 (navigation_info_->ran_insecure_content != 703 new_navigation_info.ran_insecure_content); 704 705 if (is_ssl_state_changed) { 706 int lock_status = SECURELOCK_SET_UNSECURE; 707 switch (new_navigation_info.security_style) { 708 case content::SECURITY_STYLE_AUTHENTICATED: 709 lock_status = new_navigation_info.displayed_insecure_content ? 710 SECURELOCK_SET_MIXED : SECURELOCK_SET_SECUREUNKNOWNBIT; 711 break; 712 default: 713 break; 714 } 715 716 base::win::ScopedVariant secure_lock_status(lock_status); 717 IEExec(&CGID_ShellDocView, INTERNAL_CMDID_SET_SSL_LOCK, 718 OLECMDEXECOPT_DODEFAULT, secure_lock_status.AsInput(), NULL); 719 } 720 721 // A number of poorly written bho's crash in their event sink callbacks if 722 // chrome frame is the currently loaded document. This is because they expect 723 // chrome frame to implement interfaces like IHTMLDocument, etc. We patch the 724 // event sink's of these bho's and don't invoke the event sink if chrome 725 // frame is the currently loaded document. 726 if (GetConfigBool(true, kEnableBuggyBhoIntercept)) { 727 base::win::ScopedComPtr<IWebBrowser2> wb2; 728 DoQueryService(SID_SWebBrowserApp, m_spClientSite, wb2.Receive()); 729 if (wb2 && buggy_bho::BuggyBhoTls::GetInstance()) { 730 buggy_bho::BuggyBhoTls::GetInstance()->PatchBuggyBHOs(wb2); 731 } 732 } 733 734 // Ideally all navigations should come to Chrome Frame so that we can call 735 // BeforeNavigate2 on installed BHOs and give them a chance to cancel the 736 // navigation. However, in practice what happens is as below: 737 // The very first navigation that happens in CF happens via a Load or a 738 // LoadHistory call. In this case, IE already has the correct information for 739 // its travel log as well address bar. For other internal navigations (navs 740 // that only happen within Chrome such as anchor navigations) we need to 741 // update IE's internal state after the fact. In the case of internal 742 // navigations, we notify the BHOs but ignore the should_cancel flag. 743 744 // Another case where we need to issue BeforeNavigate2 calls is as below:- 745 // We get notified after the fact, when navigations are initiated within 746 // Chrome via window.open calls. These navigations are handled by creating 747 // an external tab container within chrome and then connecting to it from IE. 748 // We still want to update the address bar/history, etc, to ensure that 749 // the special URL used by Chrome to indicate this is updated correctly. 750 ChromeFrameUrl cf_url; 751 bool is_attach_external_tab_url = cf_url.Parse(std::wstring(url_)) && 752 cf_url.attach_to_external_tab(); 753 754 bool is_internal_navigation = 755 IsNewNavigation(new_navigation_info, flags) || is_attach_external_tab_url; 756 757 if (new_navigation_info.url.is_valid()) 758 url_.Allocate(UTF8ToWide(new_navigation_info.url.spec()).c_str()); 759 760 if (is_internal_navigation) { 761 // IE6 does not support tabs. If Chrome sent us a window open request 762 // indicating that the navigation needs to occur in a foreground tab or 763 // a popup window, then we need to ensure that the new window in IE6 is 764 // brought to the foreground. 765 if (GetIEVersion() == IE_6 && 766 is_attach_external_tab_url && 767 (cf_url.disposition() == NEW_FOREGROUND_TAB || 768 cf_url.disposition() == NEW_POPUP)) { 769 base::win::ScopedComPtr<IWebBrowser2> wb2; 770 DoQueryService(SID_SWebBrowserApp, m_spClientSite, wb2.Receive()); 771 if (wb2) 772 BaseActiveX::BringWebBrowserWindowToTop(wb2); 773 } 774 base::win::ScopedComPtr<IDocObjectService> doc_object_svc; 775 base::win::ScopedComPtr<IWebBrowserEventsService> web_browser_events_svc; 776 777 DoQueryService(__uuidof(web_browser_events_svc), m_spClientSite, 778 web_browser_events_svc.Receive()); 779 780 if (!web_browser_events_svc.get()) { 781 DoQueryService(SID_SShellBrowser, m_spClientSite, 782 doc_object_svc.Receive()); 783 } 784 785 // web_browser_events_svc can be NULL on IE6. 786 if (web_browser_events_svc) { 787 VARIANT_BOOL should_cancel = VARIANT_FALSE; 788 web_browser_events_svc->FireBeforeNavigate2Event(&should_cancel); 789 } else if (doc_object_svc) { 790 BOOL should_cancel = FALSE; 791 doc_object_svc->FireBeforeNavigate2(NULL, url_, 0, NULL, NULL, 0, 792 NULL, FALSE, &should_cancel); 793 } 794 795 // We need to tell IE that we support navigation so that IE will query us 796 // for IPersistHistory and call GetPositionCookie to save our navigation 797 // index. 798 base::win::ScopedVariant html_window(static_cast<IUnknown*>( 799 static_cast<IHTMLWindow2*>(this))); 800 IEExec(&CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, 801 html_window.AsInput(), NULL); 802 803 // We pass the HLNF_INTERNALJUMP flag to INTERNAL_CMDID_FINALIZE_TRAVEL_LOG 804 // since we want to make IE treat all internal navigations within this page 805 // (including anchor navigations and subframe navigations) as anchor 806 // navigations. This will ensure that IE calls GetPositionCookie 807 // to save the current position cookie in the travel log and then call 808 // SetPositionCookie when the user hits Back/Forward to come back here. 809 base::win::ScopedVariant internal_navigation(HLNF_INTERNALJUMP); 810 IEExec(&CGID_Explorer, INTERNAL_CMDID_FINALIZE_TRAVEL_LOG, 0, 811 internal_navigation.AsInput(), NULL); 812 813 // We no longer need to lie to IE. If we lie persistently to IE, then 814 // IE reuses us for new navigations. 815 IEExec(&CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, NULL, NULL); 816 817 if (doc_object_svc) { 818 // Now call the FireNavigateCompleteEvent which makes IE update the text 819 // in the address-bar. 820 doc_object_svc->FireNavigateComplete2(this, 0); 821 doc_object_svc->FireDocumentComplete(this, 0); 822 } else if (web_browser_events_svc) { 823 web_browser_events_svc->FireNavigateComplete2Event(); 824 web_browser_events_svc->FireDocumentCompleteEvent(); 825 } 826 } 827 828 if (is_title_changed) { 829 base::win::ScopedVariant title(new_navigation_info.title.c_str()); 830 IEExec(NULL, OLECMDID_SETTITLE, OLECMDEXECOPT_DONTPROMPTUSER, 831 title.AsInput(), NULL); 832 } 833 834 // There are cases in which we receive NavigationStateChanged events for 835 // provisional loads. These events will contain a new URL but will not be 836 // considered new navigations since their navigation_index is 0. For these 837 // events, do not update the navigation_info_ state, as this will muck up the 838 // travel log when the subsequent committed navigation event takes place. 839 // 840 // Given this filtering, also special-case first navigations since those 841 // are needed to initially populate navigation_info_ to keep it in sync with 842 // what was placed in the IE travel log when CF was first opened. 843 // 844 // Lastly, allow through navigation events that would neither affect the 845 // travel log nor cause the page location to change, as these will 846 // contain informational state (referrer, title, etc.) that we should 847 // preserve. 848 if (is_internal_navigation || IsFirstNavigation(new_navigation_info) || 849 new_navigation_info.url == navigation_info_->url) { 850 // It is important that we only update the navigation_info_ after we have 851 // finalized the travel log. This is because IE will ask for information 852 // such as navigation index when the travel log is finalized and we need 853 // supply the old index and not the new one. 854 *navigation_info_ = new_navigation_info; 855 } 856 857 // Update the IE zone here. Ideally we would like to do it when the active 858 // document is activated. However that does not work at times as the frame we 859 // get there is not the actual frame which handles the command. 860 IEExec(&CGID_Explorer, SBCMDID_MIXEDZONE, 0, NULL, NULL); 861 } 862 863 void ChromeActiveDocument::OnFindInPage() { 864 TabProxy* tab = GetTabProxy(); 865 if (tab) { 866 if (!find_dialog_.IsWindow()) 867 find_dialog_.Create(m_hWnd); 868 869 find_dialog_.ShowWindow(SW_SHOW); 870 } 871 } 872 873 void ChromeActiveDocument::OnViewSource() { 874 DCHECK(navigation_info_->url.is_valid()); 875 HostNavigate(GURL(content::kViewSourceScheme + std::string(":") + 876 navigation_info_->url.spec()), GURL(), NEW_WINDOW); 877 } 878 879 void ChromeActiveDocument::OnDetermineSecurityZone(const GUID* cmd_group_guid, 880 DWORD command_id, 881 DWORD cmd_exec_opt, 882 VARIANT* in_args, 883 VARIANT* out_args) { 884 // Always return URLZONE_INTERNET since that is the Chrome's behaviour. 885 // Correct step is to use MapUrlToZone(). 886 if (out_args != NULL) { 887 out_args->vt = VT_UI4; 888 out_args->ulVal = URLZONE_INTERNET; 889 } 890 } 891 892 void ChromeActiveDocument::OnDisplayPrivacyInfo() { 893 privacy_info_ = url_fetcher_->privacy_info(); 894 Reset(); 895 DoPrivacyDlg(m_hWnd, url_, this, TRUE); 896 } 897 898 void ChromeActiveDocument::OnGetZoomRange(const GUID* cmd_group_guid, 899 DWORD command_id, 900 DWORD cmd_exec_opt, 901 VARIANT* in_args, 902 VARIANT* out_args) { 903 if (out_args != NULL) { 904 out_args->vt = VT_I4; 905 out_args->lVal = 0; 906 } 907 } 908 909 void ChromeActiveDocument::OnSetZoomRange(const GUID* cmd_group_guid, 910 DWORD command_id, 911 DWORD cmd_exec_opt, 912 VARIANT* in_args, 913 VARIANT* out_args) { 914 const int kZoomIn = 125; 915 const int kZoomOut = 75; 916 917 if (in_args && V_VT(in_args) == VT_I4 && IsValid()) { 918 if (in_args->lVal == kZoomIn) { 919 automation_client_->SetZoomLevel(content::PAGE_ZOOM_IN); 920 } else if (in_args->lVal == kZoomOut) { 921 automation_client_->SetZoomLevel(content::PAGE_ZOOM_OUT); 922 } else { 923 DLOG(WARNING) << "Unsupported zoom level:" << in_args->lVal; 924 } 925 } 926 } 927 928 void ChromeActiveDocument::OnUnload(const GUID* cmd_group_guid, 929 DWORD command_id, 930 DWORD cmd_exec_opt, 931 VARIANT* in_args, 932 VARIANT* out_args) { 933 if (IsValid() && out_args) { 934 // If the navigation is attempted to the url loaded in CF, with the only 935 // difference being the addition of an anchor, IE will attempt to unload 936 // the currently loaded document which basically would end up running 937 // unload handlers on the currently loaded document thus rendering it non 938 // functional. We handle this as below:- 939 // The BHO receives the new url in the BeforeNavigate event. 940 // We compare the non anchor portions of the url in the BHO with the loaded 941 // url and if they match, we initiate a Chrome navigation to the url with 942 // the anchor which works nicely. 943 // We don't want to continue processing the unload in this case. 944 // Note:- 945 // IE handles these navigations by querying the loaded document for 946 // IHTMLDocument which then handles the new navigation. That won't work for 947 // us as we don't implement IHTMLDocument. 948 NavigationManager* mgr = NavigationManager::GetThreadInstance(); 949 DLOG_IF(ERROR, !mgr) << "Couldn't get instance of NavigationManager"; 950 if (mgr) { 951 ChromeFrameUrl url; 952 url.Parse(mgr->url()); 953 if (url.gurl().has_ref()) { 954 url_canon::Replacements<char> replacements; 955 replacements.ClearRef(); 956 957 if (url.gurl().ReplaceComponents(replacements) == 958 GURL(static_cast<BSTR>(url_))) { 959 // We want to reuse the existing automation client and channel for 960 // initiating the new navigation. Setting the 961 // is_automation_client_reused_ flag to true before calling the 962 // LaunchUrl function achieves that. 963 is_automation_client_reused_ = true; 964 LaunchUrl(url, mgr->referrer()); 965 out_args->vt = VT_BOOL; 966 out_args->boolVal = VARIANT_FALSE; 967 return; 968 } 969 } 970 } 971 bool should_unload = true; 972 automation_client_->OnUnload(&should_unload); 973 out_args->vt = VT_BOOL; 974 out_args->boolVal = should_unload ? VARIANT_TRUE : VARIANT_FALSE; 975 } 976 } 977 978 void ChromeActiveDocument::OnAttachExternalTab( 979 const AttachExternalTabParams& params) { 980 if (!automation_client_.get()) { 981 DLOG(WARNING) << "Invalid automation client instance"; 982 return; 983 } 984 DWORD flags = 0; 985 if (params.user_gesture) 986 flags = NWMF_USERREQUESTED; 987 else if (popup_allowed_) 988 flags = NWMF_USERALLOWED; 989 990 HRESULT hr = S_OK; 991 if (popup_manager_) { 992 const std::wstring& url_wide = UTF8ToWide(params.url.spec()); 993 hr = popup_manager_->EvaluateNewWindow(url_wide.c_str(), NULL, url_, 994 NULL, FALSE, flags, 0); 995 } 996 // Allow popup 997 if (hr == S_OK) { 998 BaseActiveX::OnAttachExternalTab(params); 999 return; 1000 } 1001 1002 automation_client_->BlockExternalTab(params.cookie); 1003 } 1004 1005 bool ChromeActiveDocument::PreProcessContextMenu(HMENU menu) { 1006 base::win::ScopedComPtr<IBrowserService> browser_service; 1007 base::win::ScopedComPtr<ITravelLog> travel_log; 1008 GetBrowserServiceAndTravelLog(browser_service.Receive(), 1009 travel_log.Receive()); 1010 if (!browser_service || !travel_log) 1011 return true; 1012 1013 EnableMenuItem(menu, IDC_BACK, MF_BYCOMMAND | 1014 (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_BACK, 1015 NULL)) ? 1016 MF_ENABLED : MF_DISABLED)); 1017 EnableMenuItem(menu, IDC_FORWARD, MF_BYCOMMAND | 1018 (SUCCEEDED(travel_log->GetTravelEntry(browser_service, TLOG_FORE, 1019 NULL)) ? 1020 MF_ENABLED : MF_DISABLED)); 1021 // Call base class (adds 'About' item) 1022 return BaseActiveX::PreProcessContextMenu(menu); 1023 } 1024 1025 bool ChromeActiveDocument::HandleContextMenuCommand( 1026 UINT cmd, const MiniContextMenuParams& params) { 1027 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1028 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 1029 1030 if (cmd == IDC_BACK) 1031 web_browser2->GoBack(); 1032 else if (cmd == IDC_FORWARD) 1033 web_browser2->GoForward(); 1034 else if (cmd == IDC_RELOAD) 1035 web_browser2->Refresh(); 1036 else 1037 return BaseActiveX::HandleContextMenuCommand(cmd, params); 1038 1039 return true; 1040 } 1041 1042 HRESULT ChromeActiveDocument::IEExec(const GUID* cmd_group_guid, 1043 DWORD command_id, DWORD cmd_exec_opt, 1044 VARIANT* in_args, VARIANT* out_args) { 1045 HRESULT hr = E_FAIL; 1046 1047 base::win::ScopedComPtr<IOleCommandTarget> frame_cmd_target; 1048 1049 base::win::ScopedComPtr<IOleInPlaceSite> in_place_site(m_spInPlaceSite); 1050 if (!in_place_site.get() && m_spClientSite != NULL) 1051 in_place_site.QueryFrom(m_spClientSite); 1052 1053 if (in_place_site) 1054 hr = frame_cmd_target.QueryFrom(in_place_site); 1055 1056 if (frame_cmd_target) { 1057 hr = frame_cmd_target->Exec(cmd_group_guid, command_id, cmd_exec_opt, 1058 in_args, out_args); 1059 } 1060 1061 return hr; 1062 } 1063 1064 bool ChromeActiveDocument::LaunchUrl(const ChromeFrameUrl& cf_url, 1065 const std::string& referrer) { 1066 DCHECK(!cf_url.gurl().is_empty()); 1067 1068 if (!automation_client_.get()) { 1069 // http://code.google.com/p/chromium/issues/detail?id=52894 1070 // Still not sure how this happens. 1071 DLOG(ERROR) << "No automation client!"; 1072 if (!Initialize()) { 1073 NOTREACHED() << "...and failed to start a new one >:("; 1074 return false; 1075 } 1076 } 1077 1078 document_url_ = cf_url.gurl().spec(); 1079 1080 url_.Allocate(UTF8ToWide(cf_url.gurl().spec()).c_str()); 1081 if (cf_url.attach_to_external_tab()) { 1082 automation_client_->AttachExternalTab(cf_url.cookie()); 1083 OnMoveWindow(cf_url.dimensions()); 1084 } else if (!automation_client_->InitiateNavigation(cf_url.gurl().spec(), 1085 referrer, 1086 this)) { 1087 DLOG(ERROR) << "Invalid URL: " << url_; 1088 Error(L"Invalid URL"); 1089 url_.Reset(); 1090 return false; 1091 } 1092 1093 if (is_automation_client_reused_) 1094 return true; 1095 1096 automation_client_->SetUrlFetcher(url_fetcher_.get()); 1097 if (launch_params_) { 1098 return automation_client_->Initialize(this, launch_params_); 1099 } else { 1100 std::wstring profile = UTF8ToWide(cf_url.profile_name()); 1101 // If no profile was given, then make use of the host process's name. 1102 if (profile.empty()) 1103 profile = GetHostProcessName(false); 1104 return InitializeAutomation(profile, IsIEInPrivate(), 1105 false, cf_url.gurl(), GURL(referrer), 1106 false); 1107 } 1108 } 1109 1110 HRESULT ChromeActiveDocument::OnRefreshPage(const GUID* cmd_group_guid, 1111 DWORD command_id, DWORD cmd_exec_opt, VARIANT* in_args, VARIANT* out_args) { 1112 DVLOG(1) << __FUNCTION__; 1113 popup_allowed_ = false; 1114 if (in_args->vt == VT_I4 && 1115 in_args->lVal & OLECMDIDF_REFRESH_PAGEACTION_POPUPWINDOW) { 1116 popup_allowed_ = true; 1117 1118 // Ask the yellow security band to change the text and icon and to remain 1119 // visible. 1120 IEExec(&CGID_DocHostCommandHandler, OLECMDID_PAGEACTIONBLOCKED, 1121 0x80000000 | OLECMDIDF_WINDOWSTATE_USERVISIBLE_VALID, NULL, NULL); 1122 } 1123 1124 NavigationManager* mgr = NavigationManager::GetThreadInstance(); 1125 DLOG_IF(ERROR, !mgr) << "Couldn't get instance of NavigationManager"; 1126 1127 // If ChromeFrame was activated on this page as a result of a document 1128 // received in response to a top level post, then we ask the user for 1129 // permission to repost and issue a navigation with the saved post data 1130 // which reinitates the whole sequence, i.e. the server receives the top 1131 // level post and chrome frame will be reactivated in response. 1132 if (mgr && mgr->post_data().type() != VT_EMPTY) { 1133 if (MessageBox( 1134 SimpleResourceLoader::Get(IDS_HTTP_POST_WARNING).c_str(), 1135 SimpleResourceLoader::Get(IDS_HTTP_POST_WARNING_TITLE).c_str(), 1136 MB_YESNO | MB_ICONEXCLAMATION) == IDYES) { 1137 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1138 DoQueryService(SID_SWebBrowserApp, m_spClientSite, 1139 web_browser2.Receive()); 1140 DCHECK(web_browser2); 1141 VARIANT empty = base::win::ScopedVariant::kEmptyVariant; 1142 VARIANT flags = { VT_I4 }; 1143 V_I4(&flags) = navNoHistory; 1144 1145 return web_browser2->Navigate2(base::win::ScopedVariant(url_).AsInput(), 1146 &flags, 1147 &empty, 1148 const_cast<VARIANT*>(&mgr->post_data()), 1149 const_cast<VARIANT*>(&mgr->headers())); 1150 } else { 1151 return S_OK; 1152 } 1153 } 1154 1155 TabProxy* tab_proxy = GetTabProxy(); 1156 if (tab_proxy) { 1157 tab_proxy->ReloadAsync(); 1158 } else { 1159 DLOG(ERROR) << "No automation proxy"; 1160 DCHECK(automation_client_.get() != NULL) << "how did it get freed?"; 1161 // The current url request manager (url_fetcher_) has been switched to 1162 // a stopping state so we need to reset it and get a new one for the new 1163 // automation server. 1164 ResetUrlRequestManager(); 1165 url_fetcher_->set_frame_busting(false); 1166 // And now launch the current URL again. This starts a new server process. 1167 DCHECK(navigation_info_->url.is_valid()); 1168 ChromeFrameUrl cf_url; 1169 cf_url.Parse(UTF8ToWide(navigation_info_->url.spec())); 1170 LaunchUrl(cf_url, navigation_info_->referrer.spec()); 1171 } 1172 1173 return S_OK; 1174 } 1175 1176 HRESULT ChromeActiveDocument::SetPageFontSize(const GUID* cmd_group_guid, 1177 DWORD command_id, 1178 DWORD cmd_exec_opt, 1179 VARIANT* in_args, 1180 VARIANT* out_args) { 1181 if (!automation_client_.get()) { 1182 NOTREACHED() << "Invalid automation client"; 1183 return E_FAIL; 1184 } 1185 1186 switch (command_id) { 1187 case IDM_BASELINEFONT1: 1188 automation_client_->SetPageFontSize(SMALLEST_FONT); 1189 break; 1190 1191 case IDM_BASELINEFONT2: 1192 automation_client_->SetPageFontSize(SMALL_FONT); 1193 break; 1194 1195 case IDM_BASELINEFONT3: 1196 automation_client_->SetPageFontSize(MEDIUM_FONT); 1197 break; 1198 1199 case IDM_BASELINEFONT4: 1200 automation_client_->SetPageFontSize(LARGE_FONT); 1201 break; 1202 1203 case IDM_BASELINEFONT5: 1204 automation_client_->SetPageFontSize(LARGEST_FONT); 1205 break; 1206 1207 default: 1208 NOTREACHED() << "Invalid font size command: " 1209 << command_id; 1210 return E_FAIL; 1211 } 1212 1213 // Forward the command back to IEFrame with group set to 1214 // CGID_ExplorerBarDoc. This is probably needed to update the menu state to 1215 // indicate that the font size was set. This currently fails with error 1216 // 0x80040104. 1217 // TODO(iyengar) 1218 // Do some investigation into why this Exec call fails. 1219 IEExec(&CGID_ExplorerBarDoc, command_id, cmd_exec_opt, NULL, NULL); 1220 return S_OK; 1221 } 1222 1223 HRESULT ChromeActiveDocument::OnEncodingChange(const GUID* cmd_group_guid, 1224 DWORD command_id, 1225 DWORD cmd_exec_opt, 1226 VARIANT* in_args, 1227 VARIANT* out_args) { 1228 const struct EncodingMapData { 1229 DWORD ie_encoding_id; 1230 const char* chrome_encoding_name; 1231 } kEncodingTestDatas[] = { 1232 #define DEFINE_ENCODING_MAP(encoding_name, id, chrome_name) \ 1233 { encoding_name, chrome_name }, 1234 INTERNAL_IE_ENCODINGMENU_IDS(DEFINE_ENCODING_MAP) 1235 #undef DEFINE_ENCODING_MAP 1236 }; 1237 1238 if (!automation_client_.get()) { 1239 NOTREACHED() << "Invalid automtion client"; 1240 return E_FAIL; 1241 } 1242 1243 // Using ARRAYSIZE_UNSAFE in here is because we define the struct 1244 // EncodingMapData inside function. 1245 const char* chrome_encoding_name = NULL; 1246 for (int i = 0; i < ARRAYSIZE_UNSAFE(kEncodingTestDatas); ++i) { 1247 const struct EncodingMapData* encoding_data = &kEncodingTestDatas[i]; 1248 if (command_id == encoding_data->ie_encoding_id) { 1249 chrome_encoding_name = encoding_data->chrome_encoding_name; 1250 break; 1251 } 1252 } 1253 // Return E_FAIL when encountering invalid encoding id. 1254 if (!chrome_encoding_name) 1255 return E_FAIL; 1256 1257 TabProxy* tab = GetTabProxy(); 1258 if (!tab) { 1259 NOTREACHED() << "Can not get TabProxy"; 1260 return E_FAIL; 1261 } 1262 1263 if (chrome_encoding_name) 1264 tab->OverrideEncoding(chrome_encoding_name); 1265 1266 // Like we did on SetPageFontSize, we may forward the command back to IEFrame 1267 // to update the menu state to indicate that which encoding was set. 1268 // TODO(iyengar) 1269 // Do some investigation into why this Exec call fails. 1270 IEExec(&CGID_ExplorerBarDoc, command_id, cmd_exec_opt, NULL, NULL); 1271 return S_OK; 1272 } 1273 1274 void ChromeActiveDocument::OnGoToHistoryEntryOffset(int offset) { 1275 DVLOG(1) << __FUNCTION__ << " - offset:" << offset; 1276 1277 base::win::ScopedComPtr<IBrowserService> browser_service; 1278 base::win::ScopedComPtr<ITravelLog> travel_log; 1279 GetBrowserServiceAndTravelLog(browser_service.Receive(), 1280 travel_log.Receive()); 1281 1282 if (browser_service && travel_log) 1283 travel_log->Travel(browser_service, offset); 1284 } 1285 1286 void ChromeActiveDocument::OnMoveWindow(const gfx::Rect& dimensions) { 1287 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1288 DoQueryService(SID_SWebBrowserApp, m_spClientSite, 1289 web_browser2.Receive()); 1290 if (!web_browser2) 1291 return; 1292 DVLOG(1) << "this:" << this << "\ndimensions: width:" << dimensions.width() 1293 << " height:" << dimensions.height(); 1294 if (!dimensions.IsEmpty()) { 1295 web_browser2->put_MenuBar(VARIANT_FALSE); 1296 web_browser2->put_ToolBar(VARIANT_FALSE); 1297 1298 int width = dimensions.width(); 1299 int height = dimensions.height(); 1300 // Compute the size of the browser window given the desired size of the 1301 // content area. As per MSDN, the WebBrowser object returns an error from 1302 // this method. As a result the code below is best effort. 1303 web_browser2->ClientToWindow(&width, &height); 1304 1305 web_browser2->put_Width(width); 1306 web_browser2->put_Height(height); 1307 web_browser2->put_Left(dimensions.x()); 1308 web_browser2->put_Top(dimensions.y()); 1309 } 1310 } 1311 1312 HRESULT ChromeActiveDocument::GetBrowserServiceAndTravelLog( 1313 IBrowserService** browser_service, ITravelLog** travel_log) { 1314 DCHECK(browser_service || travel_log); 1315 base::win::ScopedComPtr<IBrowserService> browser_service_local; 1316 HRESULT hr = DoQueryService(SID_SShellBrowser, m_spClientSite, 1317 browser_service_local.Receive()); 1318 if (!browser_service_local) { 1319 NOTREACHED() << "DoQueryService for IBrowserService failed: " << hr; 1320 return hr; 1321 } 1322 1323 if (travel_log) { 1324 hr = browser_service_local->GetTravelLog(travel_log); 1325 DVLOG_IF(1, !travel_log) << "browser_service->GetTravelLog failed: " << hr; 1326 } 1327 1328 if (browser_service) 1329 *browser_service = browser_service_local.Detach(); 1330 1331 return hr; 1332 } 1333 1334 LRESULT ChromeActiveDocument::OnForward(WORD notify_code, WORD id, 1335 HWND control_window, 1336 BOOL& bHandled) { 1337 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1338 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 1339 DCHECK(web_browser2); 1340 1341 if (web_browser2) 1342 web_browser2->GoForward(); 1343 return 0; 1344 } 1345 1346 LRESULT ChromeActiveDocument::OnBack(WORD notify_code, WORD id, 1347 HWND control_window, 1348 BOOL& bHandled) { 1349 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1350 DoQueryService(SID_SWebBrowserApp, m_spClientSite, web_browser2.Receive()); 1351 DCHECK(web_browser2); 1352 1353 if (web_browser2) 1354 web_browser2->GoBack(); 1355 return 0; 1356 } 1357 1358 LRESULT ChromeActiveDocument::OnFirePrivacyChange(UINT message, WPARAM wparam, 1359 LPARAM lparam, 1360 BOOL& handled) { 1361 if (!m_spClientSite) 1362 return 0; 1363 1364 base::win::ScopedComPtr<IWebBrowser2> web_browser2; 1365 DoQueryService(SID_SWebBrowserApp, m_spClientSite, 1366 web_browser2.Receive()); 1367 if (!web_browser2) { 1368 NOTREACHED() << "Failed to retrieve IWebBrowser2 interface."; 1369 return 0; 1370 } 1371 1372 base::win::ScopedComPtr<IShellBrowser> shell_browser; 1373 DoQueryService(SID_STopLevelBrowser, web_browser2, 1374 shell_browser.Receive()); 1375 DCHECK(shell_browser.get() != NULL); 1376 base::win::ScopedComPtr<ITridentService2> trident_services; 1377 trident_services.QueryFrom(shell_browser); 1378 if (trident_services) 1379 trident_services->FirePrivacyImpactedStateChange(wparam); 1380 else 1381 NOTREACHED() << "Failed to retrieve IWebBrowser2 interface."; 1382 return 0; 1383 } 1384 1385 LRESULT ChromeActiveDocument::OnShowWindow(UINT message, WPARAM wparam, 1386 LPARAM lparam, 1387 BOOL& handled) { // NO_LINT 1388 if (wparam) 1389 SetFocus(); 1390 return 0; 1391 } 1392 1393 LRESULT ChromeActiveDocument::OnSetFocus(UINT message, WPARAM wparam, 1394 LPARAM lparam, 1395 BOOL& handled) { // NO_LINT 1396 if (!ignore_setfocus_) 1397 GiveFocusToChrome(false); 1398 return 0; 1399 } 1400 1401 bool ChromeActiveDocument::IsNewNavigation( 1402 const NavigationInfo& new_navigation_info, int flags) const { 1403 // A new navigation is typically an internal navigation which is initiated by 1404 // the renderer(WebKit). Condition 1 below has to be true along with the 1405 // any of the other conditions below. 1406 // 1. The navigation notification flags passed in as the flags parameter 1407 // is not INVALIDATE_TYPE_LOAD which indicates that the loading state of 1408 // the tab changed. 1409 // 2. The navigation index is greater than 0 which means that a top level 1410 // navigation was initiated on the current external tab. 1411 // 3. The navigation type has changed. 1412 // 4. The url or the referrer are different. 1413 if (flags == content::INVALIDATE_TYPE_LOAD) 1414 return false; 1415 1416 if (new_navigation_info.navigation_index <= 0) 1417 return false; 1418 1419 if (new_navigation_info.navigation_index == 1420 navigation_info_->navigation_index) 1421 return false; 1422 1423 if (new_navigation_info.navigation_type != navigation_info_->navigation_type) 1424 return true; 1425 1426 if (new_navigation_info.url != navigation_info_->url) 1427 return true; 1428 1429 if (new_navigation_info.referrer != navigation_info_->referrer) 1430 return true; 1431 1432 return false; 1433 } 1434 1435 bool ChromeActiveDocument::IsFirstNavigation( 1436 const NavigationInfo& new_navigation_info) const { 1437 return (navigation_info_->url.is_empty() && 1438 new_navigation_info.navigation_type == 1439 content::NAVIGATION_TYPE_NEW_PAGE); 1440 } 1441
