Pass the render process id to the FrameNavigationState.

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 161 matching lines @@
   if (!tab_observer) {
     // If you hit this DCHECK(), please add reproduction steps to
     // http://crbug.com/109464.
     DCHECK(chrome::GetViewType(details->source_web_contents) !=
            chrome::VIEW_TYPE_TAB_CONTENTS);
     return;
   }
   const FrameNavigationState& frame_navigation_state =
       tab_observer->frame_navigation_state();
 
-  if (!frame_navigation_state.CanSendEvents(details->source_frame_id))
+  FrameNavigationState::FrameID frame_id(
+      details->source_frame_id,
+      details->source_web_contents->GetRenderViewHost()->GetProcess()->GetID());
+  if (!frame_navigation_state.CanSendEvents(frame_id))
     return;
 
   // If the WebContents was created as a response to an IPC from a renderer
   // (and therefore doesn't yet have a TabContents), or if it isn't yet inserted
   // into a tab strip, we need to delay the extension event until the
   // WebContents is fully initialized.
   if (TabContents::FromWebContents(details->target_web_contents) == NULL ||
       details->not_yet_in_tabstrip) {
     pending_web_contents_[details->target_web_contents] =
         PendingWebContents(
             details->source_web_contents,
             details->source_frame_id,
-            frame_navigation_state.IsMainFrame(details->source_frame_id),
+            frame_navigation_state.IsMainFrame(frame_id),
             details->target_web_contents,
             details->target_url);
   } else {
     helpers::DispatchOnCreatedNavigationTarget(
         details->source_web_contents,
         details->target_web_contents->GetBrowserContext(),
         details->source_frame_id,
-        frame_navigation_state.IsMainFrame(details->source_frame_id),
+        frame_navigation_state.IsMainFrame(frame_id),
         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;
@@ skipping 46 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: {
       content::ResourceRedirectDetails* resource_redirect_details =
           content::Details<content::ResourceRedirectDetails>(details).ptr();
       ResourceType::Type resource_type =
           resource_redirect_details->resource_type;
       if (resource_type == ResourceType::MAIN_FRAME ||
           resource_type == ResourceType::SUB_FRAME) {
-        int64 frame_id = resource_redirect_details->frame_id;
+        FrameNavigationState::FrameID frame_id(
+            resource_redirect_details->frame_id,
+            resource_redirect_details->origin_child_id);
         if (!navigation_state_.CanSendEvents(frame_id))
           return;
         navigation_state_.SetIsServerRedirected(frame_id);
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 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_) {
     // TODO(jochen): If pending_render_view_host_ is non-NULL, send error events
     // for all ongoing navigations in that RVH.
     pending_render_view_host_ = render_view_host;
   }
 }
 
 void WebNavigationTabObserver::DidStartProvisionalLoadForFrame(
-    int64 frame_id,
+    int64 frame_num,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     content::RenderViewHost* render_view_host) {
   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;
 
+  FrameNavigationState::FrameID frame_id(
+      frame_num, render_view_host->GetProcess()->GetID());
+
   navigation_state_.TrackFrame(frame_id,
                                validated_url,
                                is_main_frame,
                                is_error_page);
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   helpers::DispatchOnBeforeNavigate(
-      web_contents(), render_view_host->GetProcess()->GetID(), frame_id,
+      web_contents(), render_view_host->GetProcess()->GetID(), frame_num,
       is_main_frame, validated_url);
 }
 
 void WebNavigationTabObserver::DidCommitProvisionalLoadForFrame(
-    int64 frame_id,
+    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_)
     return;
   // TODO(jochen): If we switched the RVH, send error events for all ongoing
   // navigations in the old RVH.
   render_view_host_ = render_view_host;
   pending_render_view_host_ = NULL;
 
+  FrameNavigationState::FrameID frame_id(
+      frame_num, render_view_host->GetProcess()->GetID());
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   bool is_reference_fragment_navigation =
       IsReferenceFragmentNavigation(frame_id, url);
   bool is_history_navigation =
       navigation_state_.GetNavigationCommitted(frame_id);
 
   // Update the URL as it might have changed.
   navigation_state_.UpdateFrame(frame_id, url);
   navigation_state_.SetNavigationCommitted(frame_id);
 
   if (is_reference_fragment_navigation) {
     helpers::DispatchOnCommitted(
         keys::kOnReferenceFragmentUpdated,
         web_contents(),
-        frame_id,
+        frame_num,
         is_main_frame,
         url,
         transition_type);
     navigation_state_.SetNavigationCompleted(frame_id);
   } else if (is_history_navigation) {
     // Make the transition type match the one for reference fragment updates.
     transition_type = static_cast<content::PageTransition>(
         transition_type | content::PAGE_TRANSITION_CLIENT_REDIRECT);
     helpers::DispatchOnCommitted(
         keys::kOnHistoryStateUpdated,
         web_contents(),
-        frame_id,
+        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_id,
+        frame_num,
         is_main_frame,
         url,
         transition_type);
   }
 }
 
 void WebNavigationTabObserver::DidFailProvisionalLoad(
-    int64 frame_id,
+    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;
   if (render_view_host == pending_render_view_host_)
     pending_render_view_host_ = NULL;
 
+  FrameNavigationState::FrameID frame_id(
+      frame_num, render_view_host->GetProcess()->GetID());
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   navigation_state_.SetErrorOccurredInFrame(frame_id);
   helpers::DispatchOnErrorOccurred(
       web_contents(), render_view_host->GetProcess()->GetID(), validated_url,
-      frame_id, is_main_frame, error_code);
+      frame_num, is_main_frame, error_code);
 }
 
 void WebNavigationTabObserver::DocumentLoadedInFrame(
-    int64 frame_id,
+    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->GetProcess()->GetID());
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   helpers::DispatchOnDOMContentLoaded(web_contents(),
                                       navigation_state_.GetUrl(frame_id),
                                       navigation_state_.IsMainFrame(frame_id),
-                                      frame_id);
+                                      frame_num);
 }
 
 void WebNavigationTabObserver::DidFinishLoad(
-    int64 frame_id,
+    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->GetProcess()->GetID());
   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_id);
+                               frame_num);
 }
 
 void WebNavigationTabObserver::DidFailLoad(
-    int64 frame_id,
+    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->GetProcess()->GetID());
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   navigation_state_.SetErrorOccurredInFrame(frame_id);
   helpers::DispatchOnErrorOccurred(
       web_contents(), render_view_host->GetProcess()->GetID(), validated_url,
-      frame_id, is_main_frame, error_code);
+      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_id) {
-  if (!navigation_state_.CanSendEvents(source_frame_id))
+    int64 source_frame_num) {
+  FrameNavigationState::FrameID frame_id(
+      source_frame_num, render_view_host_->GetProcess()->GetID());
+  if (!navigation_state_.CanSendEvents(frame_id))
     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_id,
-      navigation_state_.IsMainFrame(source_frame_id),
+      source_frame_num,
+      navigation_state_.IsMainFrame(frame_id),
       new_contents,
       url);
 }
 
 void WebNavigationTabObserver::WebContentsDestroyed(content::WebContents* tab) {
   g_tab_observer.Get().erase(tab);
   for (FrameNavigationState::const_iterator frame = navigation_state_.begin();
        frame != navigation_state_.end(); ++frame) {
     if (!navigation_state_.GetNavigationCompleted(*frame) &&
         navigation_state_.CanSendEvents(*frame)) {
       helpers::DispatchOnErrorOccurred(
         tab,
-        tab->GetRenderViewHost()->GetProcess()->GetID(),
+        frame->render_process_id,
         navigation_state_.GetUrl(*frame),
-        *frame,
+        frame->frame_num,
         navigation_state_.IsMainFrame(*frame),
         net::ERR_ABORTED);
     }
   }
 }
 
 // See also NavigationController::IsURLInPageNavigation.
 bool WebNavigationTabObserver::IsReferenceFragmentNavigation(
-    int64 frame_id,
+    FrameNavigationState::FrameID frame_id,
     const GURL& url) {
   GURL existing_url = navigation_state_.GetUrl(frame_id);
   if (existing_url == url)
     return false;
 
   url_canon::Replacements<char> replacements;
   replacements.ClearRef();
   return existing_url.ReplaceComponents(replacements) ==
       url.ReplaceComponents(replacements);
 }
 
 bool GetFrameFunction::RunImpl() {
   scoped_ptr<GetFrame::Params> params(GetFrame::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->details.tab_id;
   int frame_id = params->details.frame_id;
+  int process_id = params->details.process_id;
 
   SetResult(Value::CreateNullValue());
 
   TabContents* tab_contents;
   if (!ExtensionTabUtil::GetTabById(tab_id,
                                     profile(),
                                     include_incognito(),
                                     NULL, NULL,
                                     &tab_contents,
                                     NULL) ||
       !tab_contents) {
     return true;
   }
 
   content::WebContents* web_contents = tab_contents->web_contents();
   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();
-  if (!frame_navigation_state.IsValidFrame(frame_id))
+    frame_id = frame_navigation_state.GetMainFrameID().frame_num;
+
+  FrameNavigationState::FrameID internal_frame_id(frame_id, process_id);
+  if (!frame_navigation_state.IsValidFrame(internal_frame_id))
     return true;
 
-  GURL frame_url = frame_navigation_state.GetUrl(frame_id);
+  GURL frame_url = frame_navigation_state.GetUrl(internal_frame_id);
   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(frame_id);
+      frame_navigation_state.GetErrorOccurredInFrame(internal_frame_id);
   results_ = GetFrame::Results::Create(frame_details);
   return true;
 }
 
 bool GetAllFramesFunction::RunImpl() {
   scoped_ptr<GetAllFrames::Params> params(GetAllFrames::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->details.tab_id;
 
   SetResult(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::DetailsElement> > result_list;
   for (FrameNavigationState::const_iterator it = navigation_state.begin();
        it != navigation_state.end(); ++it) {
-    int64 frame_id = *it;
+    FrameNavigationState::FrameID frame_id = *it;
     GURL frame_url = navigation_state.GetUrl(frame_id);
     if (!navigation_state.IsValidUrl(frame_url))
       continue;
     linked_ptr<GetAllFrames::Results::DetailsElement> frame(
         new GetAllFrames::Results::DetailsElement());
     frame->url = frame_url.spec();
     frame->frame_id = helpers::GetFrameId(
-        navigation_state.IsMainFrame(frame_id), frame_id);
+        navigation_state.IsMainFrame(frame_id), frame_id.frame_num);
+    frame->process_id = frame_id.render_process_id;
     frame->error_occurred = navigation_state.GetErrorOccurredInFrame(frame_id);
     result_list.push_back(frame);
   }
   results_ = GetAllFrames::Results::Create(result_list);
   return true;
 }
 
 }  // namespace extensions