Simplify WebNavigationApi by using RenderFrameHost internally.

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/chrome_notification_types.h"
@@ skipping 38 matching lines @@
     TabObserverMap;
 static base::LazyInstance<TabObserverMap> g_tab_observer =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // WebNavigtionEventRouter -------------------------------------------
 
 WebNavigationEventRouter::PendingWebContents::PendingWebContents()
     : source_web_contents(NULL),
-      source_frame_id(0),
-      source_frame_is_main_frame(false),
+      source_frame_host(NULL),
       target_web_contents(NULL),
       target_url() {
 }
 
 WebNavigationEventRouter::PendingWebContents::PendingWebContents(
     content::WebContents* source_web_contents,
-    int64 source_frame_id,
-    bool source_frame_is_main_frame,
+    content::RenderFrameHost* source_frame_host,
     content::WebContents* target_web_contents,
     const GURL& target_url)
     : source_web_contents(source_web_contents),
-      source_frame_id(source_frame_id),
-      source_frame_is_main_frame(source_frame_is_main_frame),
+      source_frame_host(source_frame_host),
       target_web_contents(target_web_contents),
       target_url(target_url) {
 }
 
 WebNavigationEventRouter::PendingWebContents::~PendingWebContents() {}
 
 WebNavigationEventRouter::WebNavigationEventRouter(Profile* profile)
     : profile_(profile) {
   CHECK(registrar_.IsEmpty());
   registrar_.Add(this,
@@ skipping 86 matching lines @@
       WebNavigationTabObserver::Get(details->source_web_contents);
   if (!tab_observer) {
     // If you hit this DCHECK(), please add reproduction steps to
     // http://crbug.com/109464.
     DCHECK(GetViewType(details->source_web_contents) != VIEW_TYPE_TAB_CONTENTS);
     return;
   }
   const FrameNavigationState& frame_navigation_state =
       tab_observer->frame_navigation_state();
 
-  FrameNavigationState::FrameID frame_id(
-      details->source_render_frame_id,
-      details->source_web_contents->GetRenderViewHost());
-  if (!frame_navigation_state.CanSendEvents(frame_id))
+  content::RenderFrameHost* frame_host = content::RenderFrameHost::FromID(
+      details->source_web_contents->GetRenderProcessHost()->GetID(),
+      details->source_render_frame_id);
+  if (!frame_navigation_state.CanSendEvents(frame_host))
     return;
 
   // If the WebContents isn't yet inserted into a tab strip, we need to delay
   // the extension event until the WebContents is fully initialized.
   if (details->not_yet_in_tabstrip) {
     pending_web_contents_[details->target_web_contents] =
-        PendingWebContents(
-            details->source_web_contents,
-            details->source_render_frame_id,
-            frame_navigation_state.IsMainFrame(frame_id),
-            details->target_web_contents,
-            details->target_url);
+        PendingWebContents(details->source_web_contents,
+                           frame_host,
+                           details->target_web_contents,
+                           details->target_url);
   } else {
     helpers::DispatchOnCreatedNavigationTarget(
         details->source_web_contents,
         details->target_web_contents->GetBrowserContext(),
-        details->source_render_frame_id,
-        frame_navigation_state.IsMainFrame(frame_id),
+        frame_host,
         details->target_web_contents,
         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;
 
   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_web_contents->GetRenderViewHost());
-  if (frame_navigation_state.CanSendEvents(frame_id)) {
+  if (frame_navigation_state.CanSendEvents(iter->second.source_frame_host)) {
     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.source_frame_host,
         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(); ) {
@@ skipping 50 matching lines @@
       // we consider the RenderView dead already now.
       RenderViewDeleted(content::Source<content::RenderViewHost>(source).ptr());
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
+void WebNavigationTabObserver::RenderFrameDeleted(
+    content::RenderFrameHost* render_frame_host) {
+  FrameDetached(render_frame_host);
+}
+
 void WebNavigationTabObserver::RenderViewDeleted(
     content::RenderViewHost* render_view_host) {
   if (render_view_host == render_view_host_) {
     render_view_host_ = NULL;
     if (pending_render_view_host_) {
       render_view_host_ = pending_render_view_host_;
       pending_render_view_host_ = NULL;
     }
   } else if (render_view_host == pending_render_view_host_) {
     pending_render_view_host_ = NULL;
   } else {
     return;
   }
-  SendErrorEvents(
-      web_contents(), render_view_host, FrameNavigationState::FrameID());
+  SendErrorEvents(web_contents(), render_view_host, NULL);
 }
 
 void WebNavigationTabObserver::AboutToNavigateRenderView(
     content::RenderViewHost* render_view_host) {
   if (!render_view_host_) {
     render_view_host_ = render_view_host;
   } else if (render_view_host != render_view_host_) {
     if (pending_render_view_host_) {
-      SendErrorEvents(web_contents(),
-                      pending_render_view_host_,
-                      FrameNavigationState::FrameID());
+      SendErrorEvents(web_contents(), pending_render_view_host_, NULL);
     }
     pending_render_view_host_ = render_view_host;
   }
 }
 
 void WebNavigationTabObserver::DidStartProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DVLOG(2) << "DidStartProvisionalLoad("
            << "render_view_host=" << render_view_host
            << ", frame_num=" << render_frame_host->GetRoutingID()
            << ", url=" << validated_url << ")";
   if (!render_view_host_)
     render_view_host_ = render_view_host;
   if (render_view_host != render_view_host_ &&
       render_view_host != pending_render_view_host_)
     return;
 
-  // TODO(dcheng): FrameNavigationState and the associated helpers should
-  // probably be refactored to use RenderFrameHost directly instead.
-  FrameNavigationState::FrameID frame_id(render_frame_host->GetRoutingID(),
-                                         render_view_host);
-  FrameNavigationState::FrameID parent_frame_id(
-      render_frame_host->GetParent()
-          ? render_frame_host->GetParent()->GetRoutingID()
-          : -1,
-      render_view_host);
-  bool is_main_frame = !render_frame_host->GetParent();
+  navigation_state_.TrackFrame(
+      render_frame_host, validated_url, is_error_page, is_iframe_srcdoc);
 
-  navigation_state_.TrackFrame(frame_id,
-                               parent_frame_id,
-                               validated_url,
-                               is_main_frame,
-                               is_error_page,
-                               is_iframe_srcdoc);
-
-  if (!navigation_state_.CanSendEvents(frame_id))
+  if (!navigation_state_.CanSendEvents(render_frame_host))
     return;
 
   helpers::DispatchOnBeforeNavigate(
       web_contents(),
-      render_view_host->GetProcess()->GetID(),
-      frame_id.frame_num,
-      is_main_frame,
-      parent_frame_id.frame_num,
-      navigation_state_.IsMainFrame(parent_frame_id),
-      navigation_state_.GetUrl(frame_id));
+      render_frame_host,
+      navigation_state_.GetUrl(render_frame_host));
 }
 
 void WebNavigationTabObserver::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& url,
     content::PageTransition transition_type) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DVLOG(2) << "DidCommitProvisionalLoad("
            << "render_view_host=" << render_view_host
            << ", frame_num=" << render_frame_host->GetRoutingID()
            << ", url=" << url << ")";
   if (render_view_host != render_view_host_ &&
       render_view_host != pending_render_view_host_)
     return;
-  FrameNavigationState::FrameID frame_id(render_frame_host->GetRoutingID(),
-                                         render_view_host);
-  bool is_main_frame = !render_frame_host->GetParent();
 
   bool is_reference_fragment_navigation =
-      IsReferenceFragmentNavigation(frame_id, url);
+      IsReferenceFragmentNavigation(render_frame_host, url);
   bool is_history_state_modification =
-      navigation_state_.GetNavigationCommitted(frame_id);
+      navigation_state_.GetNavigationCommitted(render_frame_host);
 
-  if (is_main_frame && render_view_host_ == render_view_host) {
+  if (!render_frame_host->GetParent() &&
+      render_view_host_ == render_view_host) {
     // Changing the reference fragment or the history state using
     // history.pushState or history.replaceState does not cancel on-going
     // iframe navigations.
     if (!is_reference_fragment_navigation && !is_history_state_modification)
-      SendErrorEvents(web_contents(), render_view_host_, frame_id);
+      SendErrorEvents(web_contents(), render_view_host_, render_frame_host);
     if (pending_render_view_host_) {
-      SendErrorEvents(web_contents(),
-                      pending_render_view_host_,
-                      FrameNavigationState::FrameID());
+      SendErrorEvents(web_contents(), pending_render_view_host_, NULL);
       pending_render_view_host_ = NULL;
     }
   } else if (pending_render_view_host_ == render_view_host) {
-    SendErrorEvents(
-        web_contents(), render_view_host_, FrameNavigationState::FrameID());
+    SendErrorEvents(web_contents(), render_view_host_, NULL);
     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);
+  navigation_state_.UpdateFrame(render_frame_host, url);
+  navigation_state_.SetNavigationCommitted(render_frame_host);
 
-  if (!navigation_state_.CanSendEvents(frame_id))
+  if (!navigation_state_.CanSendEvents(render_frame_host))
     return;
 
   if (is_reference_fragment_navigation) {
     helpers::DispatchOnCommitted(
         web_navigation::OnReferenceFragmentUpdated::kEventName,
         web_contents(),
-        render_frame_host->GetRoutingID(),
-        is_main_frame,
-        navigation_state_.GetUrl(frame_id),
+        render_frame_host,
+        navigation_state_.GetUrl(render_frame_host),
         transition_type);
   } else if (is_history_state_modification) {
     helpers::DispatchOnCommitted(
         web_navigation::OnHistoryStateUpdated::kEventName,
         web_contents(),
-        render_frame_host->GetRoutingID(),
-        is_main_frame,
-        navigation_state_.GetUrl(frame_id),
+        render_frame_host,
+        navigation_state_.GetUrl(render_frame_host),
         transition_type);
   } else {
-    if (navigation_state_.GetIsServerRedirected(frame_id)) {
+    if (navigation_state_.GetIsServerRedirected(render_frame_host)) {
       transition_type = static_cast<content::PageTransition>(
           transition_type | content::PAGE_TRANSITION_SERVER_REDIRECT);
     }
     helpers::DispatchOnCommitted(web_navigation::OnCommitted::kEventName,
                                  web_contents(),
-                                 render_frame_host->GetRoutingID(),
-                                 is_main_frame,
-                                 navigation_state_.GetUrl(frame_id),
+                                 render_frame_host,
+                                 navigation_state_.GetUrl(render_frame_host),
                                  transition_type);
   }
 }
 
 void WebNavigationTabObserver::DidFailProvisionalLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
     const base::string16& error_description) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DVLOG(2) << "DidFailProvisionalLoad("
            << "render_view_host=" << render_view_host
            << ", frame_num=" << render_frame_host->GetRoutingID()
            << ", url=" << validated_url << ")";
   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(render_frame_host->GetRoutingID(),
-                                         render_view_host);
-  bool is_main_frame = !render_frame_host->GetParent();
-
-  if (navigation_state_.CanSendEvents(frame_id)) {
-    helpers::DispatchOnErrorOccurred(web_contents(),
-                                     render_view_host->GetProcess()->GetID(),
-                                     navigation_state_.GetUrl(frame_id),
-                                     render_frame_host->GetRoutingID(),
-                                     is_main_frame,
-                                     error_code);
+  if (navigation_state_.CanSendEvents(render_frame_host)) {
+    helpers::DispatchOnErrorOccurred(
+        web_contents(),
+        render_frame_host,
+        navigation_state_.GetUrl(render_frame_host),
+        error_code);
   }
-  navigation_state_.SetErrorOccurredInFrame(frame_id);
+  navigation_state_.SetErrorOccurredInFrame(render_frame_host);
   if (stop_tracking_frames) {
-    navigation_state_.StopTrackingFramesInRVH(render_view_host,
-                                              FrameNavigationState::FrameID());
+    navigation_state_.StopTrackingFramesInRVH(render_view_host, NULL);
   }
 }
 
 void WebNavigationTabObserver::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DVLOG(2) << "DocumentLoadedInFrame("
            << "render_view_host=" << render_view_host
            << ", frame_num=" << render_frame_host->GetRoutingID() << ")";
   if (render_view_host != render_view_host_)
     return;
-  FrameNavigationState::FrameID frame_id(render_frame_host->GetRoutingID(),
-                                         render_view_host);
-  if (!navigation_state_.CanSendEvents(frame_id))
+  if (!navigation_state_.CanSendEvents(render_frame_host))
     return;
-  navigation_state_.SetParsingFinished(frame_id);
-  helpers::DispatchOnDOMContentLoaded(web_contents(),
-                                      navigation_state_.GetUrl(frame_id),
-                                      navigation_state_.IsMainFrame(frame_id),
-                                      frame_id.frame_num);
+  navigation_state_.SetParsingFinished(render_frame_host);
+  helpers::DispatchOnDOMContentLoaded(
+      web_contents(),
+      render_frame_host,
+      navigation_state_.GetUrl(render_frame_host));
 
-  if (!navigation_state_.GetNavigationCompleted(frame_id))
+  if (!navigation_state_.GetNavigationCompleted(render_frame_host))
     return;
 
   // The load might already have finished by the time we finished parsing. For
   // compatibility reasons, we artifically delay the load completed signal until
   // after parsing was completed.
   helpers::DispatchOnCompleted(web_contents(),
-                               navigation_state_.GetUrl(frame_id),
-                               navigation_state_.IsMainFrame(frame_id),
-                               frame_id.frame_num);
+                               render_frame_host,
+                               navigation_state_.GetUrl(render_frame_host));
 }
 
 void WebNavigationTabObserver::DidFinishLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DVLOG(2) << "DidFinishLoad("
            << "render_view_host=" << render_view_host
            << ", frame_num=" << render_frame_host->GetRoutingID()
            << ", url=" << validated_url << ")";
   if (render_view_host != render_view_host_)
     return;
-  FrameNavigationState::FrameID frame_id(render_frame_host->GetRoutingID(),
-                                         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))
+  if (!navigation_state_.IsValidFrame(render_frame_host))
     return;
-  navigation_state_.SetNavigationCompleted(frame_id);
-  if (!navigation_state_.CanSendEvents(frame_id))
+  navigation_state_.SetNavigationCompleted(render_frame_host);
+  if (!navigation_state_.CanSendEvents(render_frame_host))
     return;
-  DCHECK(
-      navigation_state_.GetUrl(frame_id) == validated_url ||
-      (navigation_state_.GetUrl(frame_id) == GURL(content::kAboutSrcDocURL) &&
-       validated_url == GURL(url::kAboutBlankURL)))
+  DCHECK(navigation_state_.GetUrl(render_frame_host) == validated_url ||
+         (navigation_state_.GetUrl(render_frame_host) ==
+              GURL(content::kAboutSrcDocURL) &&
+          validated_url == GURL(url::kAboutBlankURL)))
       << "validated URL is " << validated_url << " but we expected "
-      << navigation_state_.GetUrl(frame_id);
-  DCHECK_EQ(navigation_state_.IsMainFrame(frame_id),
-            !render_frame_host->GetParent());
+      << navigation_state_.GetUrl(render_frame_host);
 
   // The load might already have finished by the time we finished parsing. For
   // compatibility reasons, we artifically delay the load completed signal until
   // after parsing was completed.
-  if (!navigation_state_.GetParsingFinished(frame_id))
+  if (!navigation_state_.GetParsingFinished(render_frame_host))
     return;
   helpers::DispatchOnCompleted(web_contents(),
-                               navigation_state_.GetUrl(frame_id),
-                               !render_frame_host->GetParent(),
-                               frame_id.frame_num);
+                               render_frame_host,
+                               navigation_state_.GetUrl(render_frame_host));
 }
 
 void WebNavigationTabObserver::DidFailLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
     const base::string16& error_description) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DVLOG(2) << "DidFailLoad("
            << "render_view_host=" << render_view_host
            << ", frame_num=" << render_frame_host->GetRoutingID()
            << ", url=" << validated_url << ")";
   if (render_view_host != render_view_host_)
     return;
-  FrameNavigationState::FrameID frame_id(render_frame_host->GetRoutingID(),
-                                         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))
+  if (!navigation_state_.IsValidFrame(render_frame_host))
     return;
-  if (navigation_state_.CanSendEvents(frame_id)) {
-    helpers::DispatchOnErrorOccurred(web_contents(),
-                                     render_view_host->GetProcess()->GetID(),
-                                     navigation_state_.GetUrl(frame_id),
-                                     frame_id.frame_num,
-                                     !render_frame_host->GetParent(),
-                                     error_code);
+  if (navigation_state_.CanSendEvents(render_frame_host)) {
+    helpers::DispatchOnErrorOccurred(
+        web_contents(),
+        render_frame_host,
+        navigation_state_.GetUrl(render_frame_host),
+        error_code);
   }
-  navigation_state_.SetErrorOccurredInFrame(frame_id);
+  navigation_state_.SetErrorOccurredInFrame(render_frame_host);
 }
 
 void WebNavigationTabObserver::DidGetRedirectForResourceRequest(
     content::RenderViewHost* render_view_host,
     const content::ResourceRedirectDetails& details) {
   if (details.resource_type != ResourceType::MAIN_FRAME &&
       details.resource_type != ResourceType::SUB_FRAME) {
     return;
   }
-  FrameNavigationState::FrameID frame_id(details.render_frame_id,
-                                         render_view_host);
-  navigation_state_.SetIsServerRedirected(frame_id);
+  content::RenderFrameHost* render_frame_host =
+      content::RenderFrameHost::FromID(render_view_host->GetProcess()->GetID(),
+                                       details.render_frame_id);
+  navigation_state_.SetIsServerRedirected(render_frame_host);
 }
 
 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_);
-  if (!navigation_state_.CanSendEvents(frame_id))
+  content::RenderFrameHost* render_frame_host =
+      content::RenderFrameHost::FromID(render_view_host_->GetProcess()->GetID(),
+                                       source_frame_num);
+  if (!navigation_state_.CanSendEvents(render_frame_host))
     return;
 
   // We only send the onCreatedNavigationTarget if we end up creating a new
   // window.
   if (disposition != SINGLETON_TAB &&
       disposition != NEW_FOREGROUND_TAB &&
       disposition != NEW_BACKGROUND_TAB &&
       disposition != NEW_POPUP &&
       disposition != NEW_WINDOW &&
       disposition != OFF_THE_RECORD)
     return;
 
-  helpers::DispatchOnCreatedNavigationTarget(
-      web_contents(),
-      new_contents->GetBrowserContext(),
-      source_frame_num,
-      navigation_state_.IsMainFrame(frame_id),
-      new_contents,
-      url);
+  helpers::DispatchOnCreatedNavigationTarget(web_contents(),
+                                             new_contents->GetBrowserContext(),
+                                             render_frame_host,
+                                             new_contents,
+                                             url);
 }
 
 void WebNavigationTabObserver::FrameDetached(
     content::RenderFrameHost* render_frame_host) {
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   if (render_view_host != render_view_host_ &&
       render_view_host != pending_render_view_host_) {
     return;
   }
-  FrameNavigationState::FrameID frame_id(render_frame_host->GetRoutingID(),
-                                         render_view_host);
-  if (navigation_state_.CanSendEvents(frame_id) &&
-      !navigation_state_.GetNavigationCompleted(frame_id)) {
-    helpers::DispatchOnErrorOccurred(web_contents(),
-                                     render_view_host->GetProcess()->GetID(),
-                                     navigation_state_.GetUrl(frame_id),
-                                     frame_id.frame_num,
-                                     navigation_state_.IsMainFrame(frame_id),
-                                     net::ERR_ABORTED);
+  if (navigation_state_.CanSendEvents(render_frame_host) &&
+      !navigation_state_.GetNavigationCompleted(render_frame_host)) {
+    helpers::DispatchOnErrorOccurred(
+        web_contents(),
+        render_frame_host,
+        navigation_state_.GetUrl(render_frame_host),
+        net::ERR_ABORTED);
   }
-  navigation_state_.FrameDetached(frame_id);
+  navigation_state_.FrameDetached(render_frame_host);
 }
 
 void WebNavigationTabObserver::WebContentsDestroyed() {
   g_tab_observer.Get().erase(web_contents());
   registrar_.RemoveAll();
-  SendErrorEvents(web_contents(), NULL, FrameNavigationState::FrameID());
+  SendErrorEvents(web_contents(), NULL, NULL);
 }
 
 void WebNavigationTabObserver::SendErrorEvents(
     content::WebContents* web_contents,
     content::RenderViewHost* render_view_host,
-    FrameNavigationState::FrameID id_to_skip) {
-  for (FrameNavigationState::const_iterator frame = navigation_state_.begin();
-       frame != navigation_state_.end(); ++frame) {
-    if (!navigation_state_.GetNavigationCompleted(*frame) &&
-        navigation_state_.CanSendEvents(*frame) &&
-        *frame != id_to_skip &&
-        (!render_view_host || frame->render_view_host == render_view_host)) {
-      navigation_state_.SetErrorOccurredInFrame(*frame);
+    content::RenderFrameHost* frame_host_to_skip) {
+  for (FrameNavigationState::const_iterator it = navigation_state_.begin();
+       it != navigation_state_.end();
+       ++it) {
+    if (!navigation_state_.GetNavigationCompleted(*it) &&
+        navigation_state_.CanSendEvents(*it) && *it != frame_host_to_skip &&
+        (!render_view_host || (*it)->GetRenderViewHost() == render_view_host)) {
+      navigation_state_.SetErrorOccurredInFrame(*it);
       helpers::DispatchOnErrorOccurred(
-          web_contents,
-          frame->render_view_host->GetProcess()->GetID(),
-          navigation_state_.GetUrl(*frame),
-          frame->frame_num,
-          navigation_state_.IsMainFrame(*frame),
-          net::ERR_ABORTED);
+          web_contents, *it, navigation_state_.GetUrl(*it), net::ERR_ABORTED);
     }
   }
   if (render_view_host)
-    navigation_state_.StopTrackingFramesInRVH(render_view_host, id_to_skip);
+    navigation_state_.StopTrackingFramesInRVH(render_view_host,
+                                              frame_host_to_skip);
 }
 
 // See also NavigationController::IsURLInPageNavigation.
 bool WebNavigationTabObserver::IsReferenceFragmentNavigation(
-    FrameNavigationState::FrameID frame_id,
+    content::RenderFrameHost* render_frame_host,
     const GURL& url) {
-  GURL existing_url = navigation_state_.GetUrl(frame_id);
+  GURL existing_url = navigation_state_.GetUrl(render_frame_host);
   if (existing_url == url)
     return false;
 
   url::Replacements<char> replacements;
   replacements.ClearRef();
   return existing_url.ReplaceComponents(replacements) ==
       url.ReplaceComponents(replacements);
 }
 
 bool WebNavigationGetFrameFunction::RunSync() {
@@ skipping 17 matching lines @@
     return true;
   }
 
   WebNavigationTabObserver* observer =
       WebNavigationTabObserver::Get(web_contents);
   DCHECK(observer);
 
   const FrameNavigationState& frame_navigation_state =
       observer->frame_navigation_state();
 
-  if (frame_id == 0)
-    frame_id = frame_navigation_state.GetMainFrameID().frame_num;
-
-  content::RenderViewHost* render_view_host =
-      observer->GetRenderViewHostInProcess(process_id);
-  if (!render_view_host)
+  content::RenderFrameHost* render_frame_host =
+      frame_id == 0 ? frame_navigation_state.GetLastCommittedMainFrameHost()
+                    : content::RenderFrameHost::FromID(process_id, frame_id);
+  if (!frame_navigation_state.IsValidFrame(render_frame_host))
     return true;
 
-  FrameNavigationState::FrameID internal_frame_id(frame_id, render_view_host);
-  if (!frame_navigation_state.IsValidFrame(internal_frame_id))
-    return true;
-
-  GURL frame_url = frame_navigation_state.GetUrl(internal_frame_id);
+  GURL frame_url = frame_navigation_state.GetUrl(render_frame_host);
   if (!frame_navigation_state.IsValidUrl(frame_url))
     return true;
 
   GetFrame::Results::Details frame_details;
   frame_details.url = frame_url.spec();
   frame_details.error_occurred =
-      frame_navigation_state.GetErrorOccurredInFrame(internal_frame_id);
-  FrameNavigationState::FrameID parent_frame_id =
-      frame_navigation_state.GetParentFrameID(internal_frame_id);
-  frame_details.parent_frame_id = helpers::GetFrameId(
-      frame_navigation_state.IsMainFrame(parent_frame_id),
-      parent_frame_id.frame_num);
+      frame_navigation_state.GetErrorOccurredInFrame(render_frame_host);
+  frame_details.parent_frame_id =
+      helpers::GetFrameId(render_frame_host->GetParent());
   results_ = GetFrame::Results::Create(frame_details);
   return true;
 }
 
 bool WebNavigationGetAllFramesFunction::RunSync() {
   scoped_ptr<GetAllFrames::Params> params(GetAllFrames::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->details.tab_id;
 
   SetResult(base::Value::CreateNullValue());
@@ skipping 13 matching lines @@
   WebNavigationTabObserver* observer =
       WebNavigationTabObserver::Get(web_contents);
   DCHECK(observer);
 
   const FrameNavigationState& navigation_state =
       observer->frame_navigation_state();
 
   std::vector<linked_ptr<GetAllFrames::Results::DetailsType> > result_list;
   for (FrameNavigationState::const_iterator it = navigation_state.begin();
        it != navigation_state.end(); ++it) {
-    FrameNavigationState::FrameID frame_id = *it;
-    FrameNavigationState::FrameID parent_frame_id =
-        navigation_state.GetParentFrameID(frame_id);
-    GURL frame_url = navigation_state.GetUrl(frame_id);
+    GURL frame_url = navigation_state.GetUrl(*it);
     if (!navigation_state.IsValidUrl(frame_url))
       continue;
     linked_ptr<GetAllFrames::Results::DetailsType> frame(
         new GetAllFrames::Results::DetailsType());
     frame->url = frame_url.spec();
-    frame->frame_id = helpers::GetFrameId(
-        navigation_state.IsMainFrame(frame_id), frame_id.frame_num);
-    frame->parent_frame_id = helpers::GetFrameId(
-        navigation_state.IsMainFrame(parent_frame_id),
-        parent_frame_id.frame_num);
-    frame->process_id = frame_id.render_view_host->GetProcess()->GetID();
-    frame->error_occurred = navigation_state.GetErrorOccurredInFrame(frame_id);
+    frame->frame_id = helpers::GetFrameId(*it);
+    frame->parent_frame_id = helpers::GetFrameId((*it)->GetParent());
+    frame->process_id = (*it)->GetRenderViewHost()->GetProcess()->GetID();
+    frame->error_occurred = navigation_state.GetErrorOccurredInFrame(*it);
     result_list.push_back(frame);
   }
   results_ = GetAllFrames::Results::Create(result_list);
   return true;
 }
 
 WebNavigationAPI::WebNavigationAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   event_router->RegisterObserver(this,
@@ skipping 30 matching lines @@
   return g_factory.Pointer();
 }
 
 void WebNavigationAPI::OnListenerAdded(const EventListenerInfo& details) {
   web_navigation_event_router_.reset(new WebNavigationEventRouter(
       Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions