Always keep track of frames even if we can't send events for them. Just don't send events.

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"
@@ skipping 198 matching lines @@
         details->target_url);
   }
 }
 
 void WebNavigationEventRouter::TabAdded(content::WebContents* tab) {
   std::map<content::WebContents*, PendingWebContents>::iterator iter =
       pending_web_contents_.find(tab);
   if (iter == pending_web_contents_.end())
     return;
 
-  helpers::DispatchOnCreatedNavigationTarget(
-      iter->second.source_web_contents,
-      iter->second.target_web_contents->GetBrowserContext(),
+  WebNavigationTabObserver* tab_observer =
+      WebNavigationTabObserver::Get(iter->second.source_web_contents);
+  if (!tab_observer) {
+    NOTREACHED();
+    return;
+  }
+  const FrameNavigationState& frame_navigation_state =
+      tab_observer->frame_navigation_state();
+
+  FrameNavigationState::FrameID frame_id(
       iter->second.source_frame_id,
-      iter->second.source_frame_is_main_frame,
-      iter->second.target_web_contents,
-      iter->second.target_url);
+      iter->second.source_web_contents->GetRenderViewHost());
+  if (frame_navigation_state.CanSendEvents(frame_id)) {
+    helpers::DispatchOnCreatedNavigationTarget(
+        iter->second.source_web_contents,
+        iter->second.target_web_contents->GetBrowserContext(),
+        iter->second.source_frame_id,
+        iter->second.source_frame_is_main_frame,
+        iter->second.target_web_contents,
+        iter->second.target_url);
+  }
   pending_web_contents_.erase(iter);
 }
 
 void WebNavigationEventRouter::TabDestroyed(content::WebContents* tab) {
   pending_web_contents_.erase(tab);
   for (std::map<content::WebContents*, PendingWebContents>::iterator i =
            pending_web_contents_.begin(); i != pending_web_contents_.end(); ) {
     if (i->second.source_web_contents == tab)
       pending_web_contents_.erase(i++);
     else
@@ skipping 58 matching lines @@
           render_view_host = render_view_host_;
         } else if (pending_render_view_host_ &&
                    resource_redirect_details->origin_child_id ==
                        pending_render_view_host_->GetProcess()->GetID()) {
           render_view_host = pending_render_view_host_;
         }
         if (!render_view_host)
           return;
         FrameNavigationState::FrameID frame_id(
             resource_redirect_details->frame_id, render_view_host);
-        if (!navigation_state_.CanSendEvents(frame_id))
-          return;
         navigation_state_.SetIsServerRedirected(frame_id);
       }
       break;
     }
 
     case content::NOTIFICATION_RENDER_VIEW_HOST_DELETED: {
       content::RenderViewHost* render_view_host =
           content::Source<content::RenderViewHost>(source).ptr();
       if (render_view_host == render_view_host_)
         render_view_host_ = NULL;
@@ skipping 83 matching lines @@
     SendErrorEvents(
         web_contents(), render_view_host_, FrameNavigationState::FrameID());
     render_view_host_ = pending_render_view_host_;
     pending_render_view_host_ = NULL;
   }
 
   // Update the URL as it might have changed.
   navigation_state_.UpdateFrame(frame_id, url);
   navigation_state_.SetNavigationCommitted(frame_id);
 
+  if (is_reference_fragment_navigation || is_history_state_modification)
+    navigation_state_.SetNavigationCompleted(frame_id);
+
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   if (is_reference_fragment_navigation) {
     helpers::DispatchOnCommitted(
         keys::kOnReferenceFragmentUpdated,
         web_contents(),
         frame_num,
         is_main_frame,
         url,
         transition_type);
-    navigation_state_.SetNavigationCompleted(frame_id);
   } else if (is_history_state_modification) {
     helpers::DispatchOnCommitted(
         keys::kOnHistoryStateUpdated,
         web_contents(),
         frame_num,
         is_main_frame,
         url,
         transition_type);
-    navigation_state_.SetNavigationCompleted(frame_id);
   } 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,
@@ skipping 13 matching lines @@
       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)) {
-    navigation_state_.SetErrorOccurredInFrame(frame_id);
     helpers::DispatchOnErrorOccurred(
         web_contents(), render_view_host->GetProcess()->GetID(), validated_url,
         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,
     content::RenderViewHost* render_view_host) {
   if (render_view_host != render_view_host_)
     return;
   FrameNavigationState::FrameID frame_id(frame_num, render_view_host);
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   helpers::DispatchOnDOMContentLoaded(web_contents(),
                                       navigation_state_.GetUrl(frame_id),
                                       navigation_state_.IsMainFrame(frame_id),
                                       frame_num);
 }
 
 void WebNavigationTabObserver::DidFinishLoad(
     int64 frame_num,
     const GURL& validated_url,
     bool is_main_frame,
     content::RenderViewHost* render_view_host) {
   if (render_view_host != render_view_host_)
     return;
   FrameNavigationState::FrameID frame_id(frame_num, render_view_host);
+  navigation_state_.SetNavigationCompleted(frame_id);
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
-  navigation_state_.SetNavigationCompleted(frame_id);
   DCHECK_EQ(navigation_state_.GetUrl(frame_id), validated_url);
   DCHECK_EQ(navigation_state_.IsMainFrame(frame_id), is_main_frame);
   helpers::DispatchOnCompleted(web_contents(),
                                validated_url,
                                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);
-  if (!navigation_state_.CanSendEvents(frame_id))
+  // A navigation might fail before we even started a provisional load.
+  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);
+  }
   navigation_state_.SetErrorOccurredInFrame(frame_id);
-  helpers::DispatchOnErrorOccurred(
-      web_contents(), render_view_host->GetProcess()->GetID(), validated_url,
-      frame_num, is_main_frame, error_code);
 }
 
 void WebNavigationTabObserver::DidOpenRequestedURL(
     content::WebContents* new_contents,
     const GURL& url,
     const content::Referrer& referrer,
     WindowOpenDisposition disposition,
     content::PageTransition transition,
     int64 source_frame_num) {
   FrameNavigationState::FrameID frame_id(source_frame_num, render_view_host_);
@@ skipping 155 matching lines @@
         navigation_state.IsMainFrame(frame_id), frame_id.frame_num);
     frame->process_id = frame_id.render_view_host->GetProcess()->GetID();
     frame->error_occurred = navigation_state.GetErrorOccurredInFrame(frame_id);
     result_list.push_back(frame);
   }
   results_ = GetAllFrames::Results::Create(result_list);
   return true;
 }
 
 }  // namespace extensions