When an iframe displays its srcdoc, generate navigation events for about:srcdoc

chrome/browser/extensions/api/web_navigation/web_navigation_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Implements the Chrome Extensions WebNavigation API.
 
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 
 #include "base/lazy_instance.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_constants.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/retargeting_details.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/api/web_navigation.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/url_constants.h"
 #include "net/base/net_errors.h"
 
 namespace GetFrame = extensions::api::web_navigation::GetFrame;
 namespace GetAllFrames = extensions::api::web_navigation::GetAllFrames;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::WebNavigationTabObserver)
 
 namespace extensions {
 
 namespace helpers = web_navigation_api_helpers;
@@ skipping 330 matching lines @@
     return;
 
   FrameNavigationState::FrameID frame_id(frame_num, render_view_host);
   FrameNavigationState::FrameID parent_frame_id(
       parent_frame_num, render_view_host);
 
   navigation_state_.TrackFrame(frame_id,
                                parent_frame_id,
                                validated_url,
                                is_main_frame,
-                               is_error_page);
+                               is_error_page,
+                               is_iframe_srcdoc);
+
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   helpers::DispatchOnBeforeNavigate(
       web_contents(),
       render_view_host->GetProcess()->GetID(),
       frame_num,
       is_main_frame,
       parent_frame_num,
       navigation_state_.IsMainFrame(parent_frame_id),
-      validated_url);
+      navigation_state_.GetUrl(frame_id));
 }
 
 void WebNavigationTabObserver::DidCommitProvisionalLoadForFrame(
     int64 frame_num,
     bool is_main_frame,
     const GURL& url,
     content::PageTransition transition_type,
     content::RenderViewHost* render_view_host) {
   if (render_view_host != render_view_host_ &&
       render_view_host != pending_render_view_host_)
@@ skipping 33 matching lines @@
 
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   if (is_reference_fragment_navigation) {
     helpers::DispatchOnCommitted(
         keys::kOnReferenceFragmentUpdated,
         web_contents(),
         frame_num,
         is_main_frame,
-        url,
+        navigation_state_.GetUrl(frame_id),
         transition_type);
   } else if (is_history_state_modification) {
     helpers::DispatchOnCommitted(
         keys::kOnHistoryStateUpdated,
         web_contents(),
         frame_num,
         is_main_frame,
-        url,
+        navigation_state_.GetUrl(frame_id),
         transition_type);
   } else {
     if (navigation_state_.GetIsServerRedirected(frame_id)) {
       transition_type = static_cast<content::PageTransition>(
           transition_type | content::PAGE_TRANSITION_SERVER_REDIRECT);
     }
     helpers::DispatchOnCommitted(
         keys::kOnCommitted,
         web_contents(),
         frame_num,
         is_main_frame,
-        url,
+        navigation_state_.GetUrl(frame_id),
         transition_type);
   }
 }
 
 void WebNavigationTabObserver::DidFailProvisionalLoad(
     int64 frame_num,
     bool is_main_frame,
     const GURL& validated_url,
     int error_code,
     const string16& error_description,
     content::RenderViewHost* render_view_host) {
   if (render_view_host != render_view_host_ &&
       render_view_host != pending_render_view_host_)
     return;
   bool stop_tracking_frames = false;
   if (render_view_host == pending_render_view_host_) {
     pending_render_view_host_ = NULL;
     stop_tracking_frames = true;
   }
 
   FrameNavigationState::FrameID frame_id(frame_num, render_view_host);
   if (navigation_state_.CanSendEvents(frame_id)) {
     helpers::DispatchOnErrorOccurred(
-        web_contents(), render_view_host->GetProcess()->GetID(), validated_url,
-        frame_num, is_main_frame, error_code);
+        web_contents(),
+        render_view_host->GetProcess()->GetID(),
+        navigation_state_.GetUrl(frame_id),
+        frame_num,
+        is_main_frame,
+        error_code);
   }
   navigation_state_.SetErrorOccurredInFrame(frame_id);
   if (stop_tracking_frames) {
     navigation_state_.StopTrackingFramesInRVH(render_view_host,
                                               FrameNavigationState::FrameID());
   }
 }
 
 void WebNavigationTabObserver::DocumentLoadedInFrame(
     int64 frame_num,
@@ skipping 17 matching lines @@
   if (render_view_host != render_view_host_)
     return;
   FrameNavigationState::FrameID frame_id(frame_num, render_view_host);
   // When showing replacement content, we might get load signals for frames
   // that weren't reguarly loaded.
   if (!navigation_state_.IsValidFrame(frame_id))
     return;
   navigation_state_.SetNavigationCompleted(frame_id);
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
-  DCHECK_EQ(navigation_state_.GetUrl(frame_id), validated_url);
+  DCHECK(navigation_state_.GetUrl(frame_id) == validated_url ||
+         (navigation_state_.GetUrl(frame_id) == GURL(chrome::kAboutSrcDocURL) &&
+          validated_url == GURL(chrome::kAboutBlankURL)));
   DCHECK_EQ(navigation_state_.IsMainFrame(frame_id), is_main_frame);
   helpers::DispatchOnCompleted(web_contents(),
-                               validated_url,
+                               navigation_state_.GetUrl(frame_id),
                                is_main_frame,
                                frame_num);
 }
 
 void WebNavigationTabObserver::DidFailLoad(
     int64 frame_num,
     const GURL& validated_url,
     bool is_main_frame,
     int error_code,
     const string16& error_description,
     content::RenderViewHost* render_view_host) {
   if (render_view_host != render_view_host_)
     return;
   FrameNavigationState::FrameID frame_id(frame_num, render_view_host);
   // When showing replacement content, we might get load signals for frames
   // that weren't reguarly loaded.
   if (!navigation_state_.IsValidFrame(frame_id))
     return;
   if (navigation_state_.CanSendEvents(frame_id)) {
     helpers::DispatchOnErrorOccurred(
-        web_contents(), render_view_host->GetProcess()->GetID(), validated_url,
-        frame_num, is_main_frame, error_code);
+        web_contents(),
+        render_view_host->GetProcess()->GetID(),
+        navigation_state_.GetUrl(frame_id),
+        frame_num,
+        is_main_frame,
+        error_code);
   }
   navigation_state_.SetErrorOccurredInFrame(frame_id);
 }
 
 void WebNavigationTabObserver::DidOpenRequestedURL(
     content::WebContents* new_contents,
     const GURL& url,
     const content::Referrer& referrer,
     WindowOpenDisposition disposition,
     content::PageTransition transition,
@@ skipping 209 matching lines @@
 static base::LazyInstance<ProfileKeyedAPIFactory<WebNavigationAPI> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 template <>
 ProfileKeyedAPIFactory<WebNavigationAPI>*
 ProfileKeyedAPIFactory<WebNavigationAPI>::GetInstance() {
   return &g_factory.Get();
 }
 
 }  // namespace extensions