1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Implements the Chrome Extensions WebNavigation API. 6 7 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h" 8 9 #include "base/lazy_instance.h" 10 #include "chrome/browser/chrome_notification_types.h" 11 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_constants.h" 12 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h" 13 #include "chrome/browser/extensions/extension_tab_util.h" 14 #include "chrome/browser/profiles/profile.h" 15 #include "chrome/browser/tab_contents/retargeting_details.h" 16 #include "chrome/browser/ui/browser.h" 17 #include "chrome/browser/ui/browser_iterator.h" 18 #include "chrome/browser/ui/browser_list.h" 19 #include "chrome/common/extensions/api/web_navigation.h" 20 #include "content/public/browser/navigation_details.h" 21 #include "content/public/browser/notification_service.h" 22 #include "content/public/browser/notification_types.h" 23 #include "content/public/browser/render_frame_host.h" 24 #include "content/public/browser/render_process_host.h" 25 #include "content/public/browser/render_view_host.h" 26 #include "content/public/browser/resource_request_details.h" 27 #include "content/public/browser/web_contents.h" 28 #include "content/public/common/url_constants.h" 29 #include "extensions/browser/event_router.h" 30 #include "extensions/browser/view_type_utils.h" 31 #include "net/base/net_errors.h" 32 33 using content::ResourceType; 34 35 namespace GetFrame = extensions::api::web_navigation::GetFrame; 36 namespace GetAllFrames = extensions::api::web_navigation::GetAllFrames; 37 38 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::WebNavigationTabObserver); 39 40 namespace extensions { 41 42 namespace helpers = web_navigation_api_helpers; 43 namespace keys = web_navigation_api_constants; 44 namespace web_navigation = api::web_navigation; 45 46 namespace { 47 48 typedef std::map<content::WebContents*, WebNavigationTabObserver*> 49 TabObserverMap; 50 static base::LazyInstance<TabObserverMap> g_tab_observer = 51 LAZY_INSTANCE_INITIALIZER; 52 53 } // namespace 54 55 // WebNavigtionEventRouter ------------------------------------------- 56 57 WebNavigationEventRouter::PendingWebContents::PendingWebContents() 58 : source_web_contents(NULL), 59 source_frame_host(NULL), 60 target_web_contents(NULL), 61 target_url() { 62 } 63 64 WebNavigationEventRouter::PendingWebContents::PendingWebContents( 65 content::WebContents* source_web_contents, 66 content::RenderFrameHost* source_frame_host, 67 content::WebContents* target_web_contents, 68 const GURL& target_url) 69 : source_web_contents(source_web_contents), 70 source_frame_host(source_frame_host), 71 target_web_contents(target_web_contents), 72 target_url(target_url) { 73 } 74 75 WebNavigationEventRouter::PendingWebContents::~PendingWebContents() {} 76 77 WebNavigationEventRouter::WebNavigationEventRouter(Profile* profile) 78 : profile_(profile) { 79 CHECK(registrar_.IsEmpty()); 80 registrar_.Add(this, 81 chrome::NOTIFICATION_RETARGETING, 82 content::NotificationService::AllSources()); 83 registrar_.Add(this, 84 chrome::NOTIFICATION_TAB_ADDED, 85 content::NotificationService::AllSources()); 86 registrar_.Add(this, 87 content::NOTIFICATION_WEB_CONTENTS_DESTROYED, 88 content::NotificationService::AllSources()); 89 90 BrowserList::AddObserver(this); 91 for (chrome::BrowserIterator it; !it.done(); it.Next()) 92 OnBrowserAdded(*it); 93 } 94 95 WebNavigationEventRouter::~WebNavigationEventRouter() { 96 for (chrome::BrowserIterator it; !it.done(); it.Next()) 97 OnBrowserRemoved(*it); 98 BrowserList::RemoveObserver(this); 99 } 100 101 void WebNavigationEventRouter::OnBrowserAdded(Browser* browser) { 102 if (!profile_->IsSameProfile(browser->profile())) 103 return; 104 browser->tab_strip_model()->AddObserver(this); 105 } 106 107 void WebNavigationEventRouter::OnBrowserRemoved(Browser* browser) { 108 if (!profile_->IsSameProfile(browser->profile())) 109 return; 110 browser->tab_strip_model()->RemoveObserver(this); 111 } 112 113 void WebNavigationEventRouter::TabReplacedAt( 114 TabStripModel* tab_strip_model, 115 content::WebContents* old_contents, 116 content::WebContents* new_contents, 117 int index) { 118 WebNavigationTabObserver* tab_observer = 119 WebNavigationTabObserver::Get(old_contents); 120 if (!tab_observer) { 121 // If you hit this DCHECK(), please add reproduction steps to 122 // http://crbug.com/109464. 123 DCHECK(GetViewType(old_contents) != VIEW_TYPE_TAB_CONTENTS); 124 return; 125 } 126 const FrameNavigationState& frame_navigation_state = 127 tab_observer->frame_navigation_state(); 128 129 if (!frame_navigation_state.IsValidUrl(old_contents->GetURL()) || 130 !frame_navigation_state.IsValidUrl(new_contents->GetURL())) 131 return; 132 133 helpers::DispatchOnTabReplaced(old_contents, profile_, new_contents); 134 } 135 136 void WebNavigationEventRouter::Observe( 137 int type, 138 const content::NotificationSource& source, 139 const content::NotificationDetails& details) { 140 switch (type) { 141 case chrome::NOTIFICATION_RETARGETING: { 142 Profile* profile = content::Source<Profile>(source).ptr(); 143 if (profile->GetOriginalProfile() == profile_) { 144 Retargeting( 145 content::Details<const RetargetingDetails>(details).ptr()); 146 } 147 break; 148 } 149 150 case chrome::NOTIFICATION_TAB_ADDED: 151 TabAdded(content::Details<content::WebContents>(details).ptr()); 152 break; 153 154 case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: 155 TabDestroyed(content::Source<content::WebContents>(source).ptr()); 156 break; 157 158 default: 159 NOTREACHED(); 160 } 161 } 162 163 void WebNavigationEventRouter::Retargeting(const RetargetingDetails* details) { 164 if (details->source_render_frame_id == 0) 165 return; 166 WebNavigationTabObserver* tab_observer = 167 WebNavigationTabObserver::Get(details->source_web_contents); 168 if (!tab_observer) { 169 // If you hit this DCHECK(), please add reproduction steps to 170 // http://crbug.com/109464. 171 DCHECK(GetViewType(details->source_web_contents) != VIEW_TYPE_TAB_CONTENTS); 172 return; 173 } 174 const FrameNavigationState& frame_navigation_state = 175 tab_observer->frame_navigation_state(); 176 177 content::RenderFrameHost* frame_host = content::RenderFrameHost::FromID( 178 details->source_web_contents->GetRenderProcessHost()->GetID(), 179 details->source_render_frame_id); 180 if (!frame_navigation_state.CanSendEvents(frame_host)) 181 return; 182 183 // If the WebContents isn't yet inserted into a tab strip, we need to delay 184 // the extension event until the WebContents is fully initialized. 185 if (details->not_yet_in_tabstrip) { 186 pending_web_contents_[details->target_web_contents] = 187 PendingWebContents(details->source_web_contents, 188 frame_host, 189 details->target_web_contents, 190 details->target_url); 191 } else { 192 helpers::DispatchOnCreatedNavigationTarget( 193 details->source_web_contents, 194 details->target_web_contents->GetBrowserContext(), 195 frame_host, 196 details->target_web_contents, 197 details->target_url); 198 } 199 } 200 201 void WebNavigationEventRouter::TabAdded(content::WebContents* tab) { 202 std::map<content::WebContents*, PendingWebContents>::iterator iter = 203 pending_web_contents_.find(tab); 204 if (iter == pending_web_contents_.end()) 205 return; 206 207 WebNavigationTabObserver* tab_observer = 208 WebNavigationTabObserver::Get(iter->second.source_web_contents); 209 if (!tab_observer) { 210 NOTREACHED(); 211 return; 212 } 213 const FrameNavigationState& frame_navigation_state = 214 tab_observer->frame_navigation_state(); 215 216 if (frame_navigation_state.CanSendEvents(iter->second.source_frame_host)) { 217 helpers::DispatchOnCreatedNavigationTarget( 218 iter->second.source_web_contents, 219 iter->second.target_web_contents->GetBrowserContext(), 220 iter->second.source_frame_host, 221 iter->second.target_web_contents, 222 iter->second.target_url); 223 } 224 pending_web_contents_.erase(iter); 225 } 226 227 void WebNavigationEventRouter::TabDestroyed(content::WebContents* tab) { 228 pending_web_contents_.erase(tab); 229 for (std::map<content::WebContents*, PendingWebContents>::iterator i = 230 pending_web_contents_.begin(); i != pending_web_contents_.end(); ) { 231 if (i->second.source_web_contents == tab) 232 pending_web_contents_.erase(i++); 233 else 234 ++i; 235 } 236 } 237 238 // WebNavigationTabObserver ------------------------------------------ 239 240 WebNavigationTabObserver::WebNavigationTabObserver( 241 content::WebContents* web_contents) 242 : WebContentsObserver(web_contents), 243 render_view_host_(NULL), 244 pending_render_view_host_(NULL) { 245 g_tab_observer.Get().insert(TabObserverMap::value_type(web_contents, this)); 246 registrar_.Add(this, 247 content::NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW, 248 content::NotificationService::AllSources()); 249 } 250 251 WebNavigationTabObserver::~WebNavigationTabObserver() {} 252 253 // static 254 WebNavigationTabObserver* WebNavigationTabObserver::Get( 255 content::WebContents* web_contents) { 256 TabObserverMap::iterator i = g_tab_observer.Get().find(web_contents); 257 return i == g_tab_observer.Get().end() ? NULL : i->second; 258 } 259 260 content::RenderViewHost* WebNavigationTabObserver::GetRenderViewHostInProcess( 261 int process_id) const { 262 if (render_view_host_ && 263 render_view_host_->GetProcess()->GetID() == process_id) { 264 return render_view_host_; 265 } 266 if (pending_render_view_host_ && 267 pending_render_view_host_->GetProcess()->GetID() == process_id) { 268 return pending_render_view_host_; 269 } 270 return NULL; 271 } 272 273 void WebNavigationTabObserver::Observe( 274 int type, 275 const content::NotificationSource& source, 276 const content::NotificationDetails& details) { 277 switch (type) { 278 case content::NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: { 279 // The RenderView is technically not yet deleted, but the RenderViewHost 280 // already starts to filter out some IPCs. In order to not get confused, 281 // we consider the RenderView dead already now. 282 RenderViewDeleted(content::Source<content::RenderViewHost>(source).ptr()); 283 break; 284 } 285 286 default: 287 NOTREACHED(); 288 } 289 } 290 291 void WebNavigationTabObserver::RenderFrameDeleted( 292 content::RenderFrameHost* render_frame_host) { 293 content::RenderViewHost* render_view_host = 294 render_frame_host->GetRenderViewHost(); 295 if (render_view_host != render_view_host_ && 296 render_view_host != pending_render_view_host_) { 297 return; 298 } 299 if (navigation_state_.CanSendEvents(render_frame_host) && 300 !navigation_state_.GetNavigationCompleted(render_frame_host)) { 301 helpers::DispatchOnErrorOccurred( 302 web_contents(), 303 render_frame_host, 304 navigation_state_.GetUrl(render_frame_host), 305 net::ERR_ABORTED); 306 } 307 navigation_state_.FrameDetached(render_frame_host); 308 } 309 310 void WebNavigationTabObserver::RenderViewDeleted( 311 content::RenderViewHost* render_view_host) { 312 if (render_view_host == render_view_host_) { 313 render_view_host_ = NULL; 314 if (pending_render_view_host_) { 315 render_view_host_ = pending_render_view_host_; 316 pending_render_view_host_ = NULL; 317 } 318 } else if (render_view_host == pending_render_view_host_) { 319 pending_render_view_host_ = NULL; 320 } else { 321 return; 322 } 323 SendErrorEvents(web_contents(), render_view_host, NULL); 324 } 325 326 void WebNavigationTabObserver::AboutToNavigateRenderView( 327 content::RenderViewHost* render_view_host) { 328 if (!render_view_host_) { 329 render_view_host_ = render_view_host; 330 } else if (render_view_host != render_view_host_) { 331 if (pending_render_view_host_) { 332 SendErrorEvents(web_contents(), pending_render_view_host_, NULL); 333 } 334 pending_render_view_host_ = render_view_host; 335 } 336 } 337 338 void WebNavigationTabObserver::DidStartProvisionalLoadForFrame( 339 content::RenderFrameHost* render_frame_host, 340 const GURL& validated_url, 341 bool is_error_page, 342 bool is_iframe_srcdoc) { 343 content::RenderViewHost* render_view_host = 344 render_frame_host->GetRenderViewHost(); 345 DVLOG(2) << "DidStartProvisionalLoad(" 346 << "render_view_host=" << render_view_host 347 << ", frame_num=" << render_frame_host->GetRoutingID() 348 << ", url=" << validated_url << ")"; 349 if (!render_view_host_) 350 render_view_host_ = render_view_host; 351 if (render_view_host != render_view_host_ && 352 render_view_host != pending_render_view_host_) 353 return; 354 355 navigation_state_.TrackFrame( 356 render_frame_host, validated_url, is_error_page, is_iframe_srcdoc); 357 358 if (!navigation_state_.CanSendEvents(render_frame_host)) 359 return; 360 361 helpers::DispatchOnBeforeNavigate( 362 web_contents(), 363 render_frame_host, 364 navigation_state_.GetUrl(render_frame_host)); 365 } 366 367 void WebNavigationTabObserver::DidCommitProvisionalLoadForFrame( 368 content::RenderFrameHost* render_frame_host, 369 const GURL& url, 370 ui::PageTransition transition_type) { 371 content::RenderViewHost* render_view_host = 372 render_frame_host->GetRenderViewHost(); 373 DVLOG(2) << "DidCommitProvisionalLoad(" 374 << "render_view_host=" << render_view_host 375 << ", frame_num=" << render_frame_host->GetRoutingID() 376 << ", url=" << url << ")"; 377 if (render_view_host != render_view_host_ && 378 render_view_host != pending_render_view_host_) 379 return; 380 381 bool is_reference_fragment_navigation = 382 IsReferenceFragmentNavigation(render_frame_host, url); 383 bool is_history_state_modification = 384 navigation_state_.GetNavigationCommitted(render_frame_host); 385 386 if (!render_frame_host->GetParent() && 387 render_view_host_ == render_view_host) { 388 // Changing the reference fragment or the history state using 389 // history.pushState or history.replaceState does not cancel on-going 390 // iframe navigations. 391 if (!is_reference_fragment_navigation && !is_history_state_modification) 392 SendErrorEvents(web_contents(), render_view_host_, render_frame_host); 393 if (pending_render_view_host_) { 394 SendErrorEvents(web_contents(), pending_render_view_host_, NULL); 395 pending_render_view_host_ = NULL; 396 } 397 } else if (pending_render_view_host_ == render_view_host) { 398 SendErrorEvents(web_contents(), render_view_host_, NULL); 399 render_view_host_ = pending_render_view_host_; 400 pending_render_view_host_ = NULL; 401 } 402 403 // Update the URL as it might have changed. 404 navigation_state_.UpdateFrame(render_frame_host, url); 405 navigation_state_.SetNavigationCommitted(render_frame_host); 406 407 if (!navigation_state_.CanSendEvents(render_frame_host)) 408 return; 409 410 if (is_reference_fragment_navigation) { 411 helpers::DispatchOnCommitted( 412 web_navigation::OnReferenceFragmentUpdated::kEventName, 413 web_contents(), 414 render_frame_host, 415 navigation_state_.GetUrl(render_frame_host), 416 transition_type); 417 } else if (is_history_state_modification) { 418 helpers::DispatchOnCommitted( 419 web_navigation::OnHistoryStateUpdated::kEventName, 420 web_contents(), 421 render_frame_host, 422 navigation_state_.GetUrl(render_frame_host), 423 transition_type); 424 } else { 425 if (navigation_state_.GetIsServerRedirected(render_frame_host)) { 426 transition_type = ui::PageTransitionFromInt( 427 transition_type | ui::PAGE_TRANSITION_SERVER_REDIRECT); 428 } 429 helpers::DispatchOnCommitted(web_navigation::OnCommitted::kEventName, 430 web_contents(), 431 render_frame_host, 432 navigation_state_.GetUrl(render_frame_host), 433 transition_type); 434 } 435 } 436 437 void WebNavigationTabObserver::DidFailProvisionalLoad( 438 content::RenderFrameHost* render_frame_host, 439 const GURL& validated_url, 440 int error_code, 441 const base::string16& error_description) { 442 content::RenderViewHost* render_view_host = 443 render_frame_host->GetRenderViewHost(); 444 DVLOG(2) << "DidFailProvisionalLoad(" 445 << "render_view_host=" << render_view_host 446 << ", frame_num=" << render_frame_host->GetRoutingID() 447 << ", url=" << validated_url << ")"; 448 if (render_view_host != render_view_host_ && 449 render_view_host != pending_render_view_host_) 450 return; 451 bool stop_tracking_frames = false; 452 if (render_view_host == pending_render_view_host_) { 453 pending_render_view_host_ = NULL; 454 stop_tracking_frames = true; 455 } 456 457 if (navigation_state_.CanSendEvents(render_frame_host)) { 458 helpers::DispatchOnErrorOccurred( 459 web_contents(), 460 render_frame_host, 461 navigation_state_.GetUrl(render_frame_host), 462 error_code); 463 } 464 navigation_state_.SetErrorOccurredInFrame(render_frame_host); 465 if (stop_tracking_frames) { 466 navigation_state_.StopTrackingFramesInRVH(render_view_host, NULL); 467 } 468 } 469 470 void WebNavigationTabObserver::DocumentLoadedInFrame( 471 content::RenderFrameHost* render_frame_host) { 472 content::RenderViewHost* render_view_host = 473 render_frame_host->GetRenderViewHost(); 474 DVLOG(2) << "DocumentLoadedInFrame(" 475 << "render_view_host=" << render_view_host 476 << ", frame_num=" << render_frame_host->GetRoutingID() << ")"; 477 if (render_view_host != render_view_host_) 478 return; 479 if (!navigation_state_.CanSendEvents(render_frame_host)) 480 return; 481 navigation_state_.SetParsingFinished(render_frame_host); 482 helpers::DispatchOnDOMContentLoaded( 483 web_contents(), 484 render_frame_host, 485 navigation_state_.GetUrl(render_frame_host)); 486 487 if (!navigation_state_.GetNavigationCompleted(render_frame_host)) 488 return; 489 490 // The load might already have finished by the time we finished parsing. For 491 // compatibility reasons, we artifically delay the load completed signal until 492 // after parsing was completed. 493 helpers::DispatchOnCompleted(web_contents(), 494 render_frame_host, 495 navigation_state_.GetUrl(render_frame_host)); 496 } 497 498 void WebNavigationTabObserver::DidFinishLoad( 499 content::RenderFrameHost* render_frame_host, 500 const GURL& validated_url) { 501 content::RenderViewHost* render_view_host = 502 render_frame_host->GetRenderViewHost(); 503 DVLOG(2) << "DidFinishLoad(" 504 << "render_view_host=" << render_view_host 505 << ", frame_num=" << render_frame_host->GetRoutingID() 506 << ", url=" << validated_url << ")"; 507 if (render_view_host != render_view_host_) 508 return; 509 // When showing replacement content, we might get load signals for frames 510 // that weren't reguarly loaded. 511 if (!navigation_state_.IsValidFrame(render_frame_host)) 512 return; 513 navigation_state_.SetNavigationCompleted(render_frame_host); 514 if (!navigation_state_.CanSendEvents(render_frame_host)) 515 return; 516 DCHECK(navigation_state_.GetUrl(render_frame_host) == validated_url || 517 (navigation_state_.GetUrl(render_frame_host) == 518 GURL(content::kAboutSrcDocURL) && 519 validated_url == GURL(url::kAboutBlankURL))) 520 << "validated URL is " << validated_url << " but we expected " 521 << navigation_state_.GetUrl(render_frame_host); 522 523 // The load might already have finished by the time we finished parsing. For 524 // compatibility reasons, we artifically delay the load completed signal until 525 // after parsing was completed. 526 if (!navigation_state_.GetParsingFinished(render_frame_host)) 527 return; 528 helpers::DispatchOnCompleted(web_contents(), 529 render_frame_host, 530 navigation_state_.GetUrl(render_frame_host)); 531 } 532 533 void WebNavigationTabObserver::DidFailLoad( 534 content::RenderFrameHost* render_frame_host, 535 const GURL& validated_url, 536 int error_code, 537 const base::string16& error_description) { 538 content::RenderViewHost* render_view_host = 539 render_frame_host->GetRenderViewHost(); 540 DVLOG(2) << "DidFailLoad(" 541 << "render_view_host=" << render_view_host 542 << ", frame_num=" << render_frame_host->GetRoutingID() 543 << ", url=" << validated_url << ")"; 544 if (render_view_host != render_view_host_) 545 return; 546 // When showing replacement content, we might get load signals for frames 547 // that weren't reguarly loaded. 548 if (!navigation_state_.IsValidFrame(render_frame_host)) 549 return; 550 if (navigation_state_.CanSendEvents(render_frame_host)) { 551 helpers::DispatchOnErrorOccurred( 552 web_contents(), 553 render_frame_host, 554 navigation_state_.GetUrl(render_frame_host), 555 error_code); 556 } 557 navigation_state_.SetErrorOccurredInFrame(render_frame_host); 558 } 559 560 void WebNavigationTabObserver::DidGetRedirectForResourceRequest( 561 content::RenderViewHost* render_view_host, 562 const content::ResourceRedirectDetails& details) { 563 if (details.resource_type != content::RESOURCE_TYPE_MAIN_FRAME && 564 details.resource_type != content::RESOURCE_TYPE_SUB_FRAME) { 565 return; 566 } 567 content::RenderFrameHost* render_frame_host = 568 content::RenderFrameHost::FromID(render_view_host->GetProcess()->GetID(), 569 details.render_frame_id); 570 navigation_state_.SetIsServerRedirected(render_frame_host); 571 } 572 573 void WebNavigationTabObserver::DidOpenRequestedURL( 574 content::WebContents* new_contents, 575 const GURL& url, 576 const content::Referrer& referrer, 577 WindowOpenDisposition disposition, 578 ui::PageTransition transition, 579 int64 source_frame_num) { 580 content::RenderFrameHost* render_frame_host = 581 content::RenderFrameHost::FromID(render_view_host_->GetProcess()->GetID(), 582 source_frame_num); 583 if (!navigation_state_.CanSendEvents(render_frame_host)) 584 return; 585 586 // We only send the onCreatedNavigationTarget if we end up creating a new 587 // window. 588 if (disposition != SINGLETON_TAB && 589 disposition != NEW_FOREGROUND_TAB && 590 disposition != NEW_BACKGROUND_TAB && 591 disposition != NEW_POPUP && 592 disposition != NEW_WINDOW && 593 disposition != OFF_THE_RECORD) 594 return; 595 596 helpers::DispatchOnCreatedNavigationTarget(web_contents(), 597 new_contents->GetBrowserContext(), 598 render_frame_host, 599 new_contents, 600 url); 601 } 602 603 void WebNavigationTabObserver::WebContentsDestroyed() { 604 g_tab_observer.Get().erase(web_contents()); 605 registrar_.RemoveAll(); 606 SendErrorEvents(web_contents(), NULL, NULL); 607 } 608 609 void WebNavigationTabObserver::SendErrorEvents( 610 content::WebContents* web_contents, 611 content::RenderViewHost* render_view_host, 612 content::RenderFrameHost* frame_host_to_skip) { 613 for (FrameNavigationState::const_iterator it = navigation_state_.begin(); 614 it != navigation_state_.end(); 615 ++it) { 616 if (!navigation_state_.GetNavigationCompleted(*it) && 617 navigation_state_.CanSendEvents(*it) && *it != frame_host_to_skip && 618 (!render_view_host || (*it)->GetRenderViewHost() == render_view_host)) { 619 navigation_state_.SetErrorOccurredInFrame(*it); 620 helpers::DispatchOnErrorOccurred( 621 web_contents, *it, navigation_state_.GetUrl(*it), net::ERR_ABORTED); 622 } 623 } 624 if (render_view_host) 625 navigation_state_.StopTrackingFramesInRVH(render_view_host, 626 frame_host_to_skip); 627 } 628 629 // See also NavigationController::IsURLInPageNavigation. 630 bool WebNavigationTabObserver::IsReferenceFragmentNavigation( 631 content::RenderFrameHost* render_frame_host, 632 const GURL& url) { 633 GURL existing_url = navigation_state_.GetUrl(render_frame_host); 634 if (existing_url == url) 635 return false; 636 637 url::Replacements<char> replacements; 638 replacements.ClearRef(); 639 return existing_url.ReplaceComponents(replacements) == 640 url.ReplaceComponents(replacements); 641 } 642 643 bool WebNavigationGetFrameFunction::RunSync() { 644 scoped_ptr<GetFrame::Params> params(GetFrame::Params::Create(*args_)); 645 EXTENSION_FUNCTION_VALIDATE(params.get()); 646 int tab_id = params->details.tab_id; 647 int frame_id = params->details.frame_id; 648 int process_id = params->details.process_id; 649 650 SetResult(base::Value::CreateNullValue()); 651 652 content::WebContents* web_contents; 653 if (!ExtensionTabUtil::GetTabById(tab_id, 654 GetProfile(), 655 include_incognito(), 656 NULL, 657 NULL, 658 &web_contents, 659 NULL) || 660 !web_contents) { 661 return true; 662 } 663 664 WebNavigationTabObserver* observer = 665 WebNavigationTabObserver::Get(web_contents); 666 DCHECK(observer); 667 668 const FrameNavigationState& frame_navigation_state = 669 observer->frame_navigation_state(); 670 671 content::RenderFrameHost* render_frame_host = 672 frame_id == 0 ? frame_navigation_state.GetLastCommittedMainFrameHost() 673 : content::RenderFrameHost::FromID(process_id, frame_id); 674 if (!frame_navigation_state.IsValidFrame(render_frame_host)) 675 return true; 676 677 GURL frame_url = frame_navigation_state.GetUrl(render_frame_host); 678 if (!frame_navigation_state.IsValidUrl(frame_url)) 679 return true; 680 681 GetFrame::Results::Details frame_details; 682 frame_details.url = frame_url.spec(); 683 frame_details.error_occurred = 684 frame_navigation_state.GetErrorOccurredInFrame(render_frame_host); 685 frame_details.parent_frame_id = 686 helpers::GetFrameId(render_frame_host->GetParent()); 687 results_ = GetFrame::Results::Create(frame_details); 688 return true; 689 } 690 691 bool WebNavigationGetAllFramesFunction::RunSync() { 692 scoped_ptr<GetAllFrames::Params> params(GetAllFrames::Params::Create(*args_)); 693 EXTENSION_FUNCTION_VALIDATE(params.get()); 694 int tab_id = params->details.tab_id; 695 696 SetResult(base::Value::CreateNullValue()); 697 698 content::WebContents* web_contents; 699 if (!ExtensionTabUtil::GetTabById(tab_id, 700 GetProfile(), 701 include_incognito(), 702 NULL, 703 NULL, 704 &web_contents, 705 NULL) || 706 !web_contents) { 707 return true; 708 } 709 710 WebNavigationTabObserver* observer = 711 WebNavigationTabObserver::Get(web_contents); 712 DCHECK(observer); 713 714 const FrameNavigationState& navigation_state = 715 observer->frame_navigation_state(); 716 717 std::vector<linked_ptr<GetAllFrames::Results::DetailsType> > result_list; 718 for (FrameNavigationState::const_iterator it = navigation_state.begin(); 719 it != navigation_state.end(); ++it) { 720 GURL frame_url = navigation_state.GetUrl(*it); 721 if (!navigation_state.IsValidUrl(frame_url)) 722 continue; 723 linked_ptr<GetAllFrames::Results::DetailsType> frame( 724 new GetAllFrames::Results::DetailsType()); 725 frame->url = frame_url.spec(); 726 frame->frame_id = helpers::GetFrameId(*it); 727 frame->parent_frame_id = helpers::GetFrameId((*it)->GetParent()); 728 frame->process_id = (*it)->GetRenderViewHost()->GetProcess()->GetID(); 729 frame->error_occurred = navigation_state.GetErrorOccurredInFrame(*it); 730 result_list.push_back(frame); 731 } 732 results_ = GetAllFrames::Results::Create(result_list); 733 return true; 734 } 735 736 WebNavigationAPI::WebNavigationAPI(content::BrowserContext* context) 737 : browser_context_(context) { 738 EventRouter* event_router = EventRouter::Get(browser_context_); 739 event_router->RegisterObserver(this, 740 web_navigation::OnBeforeNavigate::kEventName); 741 event_router->RegisterObserver(this, web_navigation::OnCommitted::kEventName); 742 event_router->RegisterObserver(this, web_navigation::OnCompleted::kEventName); 743 event_router->RegisterObserver( 744 this, web_navigation::OnCreatedNavigationTarget::kEventName); 745 event_router->RegisterObserver( 746 this, web_navigation::OnDOMContentLoaded::kEventName); 747 event_router->RegisterObserver( 748 this, web_navigation::OnHistoryStateUpdated::kEventName); 749 event_router->RegisterObserver(this, 750 web_navigation::OnErrorOccurred::kEventName); 751 event_router->RegisterObserver( 752 this, web_navigation::OnReferenceFragmentUpdated::kEventName); 753 event_router->RegisterObserver(this, 754 web_navigation::OnTabReplaced::kEventName); 755 } 756 757 WebNavigationAPI::~WebNavigationAPI() { 758 } 759 760 void WebNavigationAPI::Shutdown() { 761 EventRouter::Get(browser_context_)->UnregisterObserver(this); 762 } 763 764 static base::LazyInstance<BrowserContextKeyedAPIFactory<WebNavigationAPI> > 765 g_factory = LAZY_INSTANCE_INITIALIZER; 766 767 // static 768 BrowserContextKeyedAPIFactory<WebNavigationAPI>* 769 WebNavigationAPI::GetFactoryInstance() { 770 return g_factory.Pointer(); 771 } 772 773 void WebNavigationAPI::OnListenerAdded(const EventListenerInfo& details) { 774 web_navigation_event_router_.reset(new WebNavigationEventRouter( 775 Profile::FromBrowserContext(browser_context_))); 776 EventRouter::Get(browser_context_)->UnregisterObserver(this); 777 } 778 779 } // namespace extensions 780
