Implement the frame id required for the web navigation api.

chrome/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 2075 matching lines @@
       Details<PageTranslatedDetails>(&details));
 }
 
 void TabContents::OnSetSuggestResult(int32 page_id, const std::string& result) {
   if (delegate())
     delegate()->OnSetSuggestResult(page_id, result);
 }
 
 void TabContents::DidStartProvisionalLoadForFrame(
     RenderViewHost* render_view_host,
+    long long frame_id,
     bool is_main_frame,
     const GURL& url) {
   ProvisionalLoadDetails details(is_main_frame,
                                  controller_.IsURLInPageNavigation(url),
-                                 url, std::string(), false);
+                                 url, std::string(), false, frame_id);
   NotificationService::current()->Notify(
       NotificationType::FRAME_PROVISIONAL_LOAD_START,
       Source<NavigationController>(&controller_),
       Details<ProvisionalLoadDetails>(&details));
   if (is_main_frame) {
     content_settings_delegate_->ClearCookieSpecificContentSettings();
     content_settings_delegate_->ClearGeolocationContentSettings();
   }
 }
 
@@ skipping 38 matching lines @@
   displayed_insecure_content_ = true;
   SSLManager::NotifySSLInternalStateChanged();
 }
 
 void TabContents::DidRunInsecureContent(const std::string& security_origin) {
   controller_.ssl_manager()->DidRunInsecureContent(security_origin);
 }
 
 void TabContents::DidFailProvisionalLoadWithError(
     RenderViewHost* render_view_host,
+    long long frame_id,
     bool is_main_frame,
     int error_code,
     const GURL& url,
     bool showing_repost_interstitial) {
   if (net::ERR_ABORTED == error_code) {
     // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
     // This means that the interstitial won't be torn down properly, which is
     // bad. But if we have an interstitial, go back to another tab type, and
     // then load the same interstitial again, we could end up getting the first
     // interstitial's "failed" message (as a result of the cancel) when we're on
@@ skipping 25 matching lines @@
       // Update the URL display.
       NotifyNavigationStateChanged(TabContents::INVALIDATE_URL);
     }
 
     render_manager_.RendererAbortedProvisionalLoad(render_view_host);
   }
 
   // Send out a notification that we failed a provisional load with an error.
   ProvisionalLoadDetails details(is_main_frame,
                                  controller_.IsURLInPageNavigation(url),
-                                 url, std::string(), false);
+                                 url, std::string(), false, frame_id);
   details.set_error_code(error_code);
 
   NotificationService::current()->Notify(
       NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       Source<NavigationController>(&controller_),
       Details<ProvisionalLoadDetails>(&details));
 }
 
 void TabContents::DocumentLoadedInFrame() {
   controller_.DocumentLoadedInFrame();
@@ skipping 207 matching lines @@
     contents_mime_type_ = params.contents_mime_type;
 
   NavigationController::LoadCommittedDetails details;
   bool did_navigate = controller_.RendererDidNavigate(
       params, extra_invalidate_flags, &details);
 
   // Send notification about committed provisional loads. This notification is
   // different from the NAV_ENTRY_COMMITTED notification which doesn't include
   // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
   if (details.type != NavigationType::NAV_IGNORE) {
-    ProvisionalLoadDetails load_details(details.is_main_frame,
-                                        details.is_in_page,
-                                        params.url, std::string(), false);
+    // For AUTO_SUBFRAME navigations, an event for the main frame is generated
+    // that is not recorded in the navigation history. For the purpose of
+    // tracking navigation events, we treat this event as a sub frame navigation
+    // event.
+    bool is_main_frame = did_navigate ? details.is_main_frame : false;
+    ProvisionalLoadDetails load_details(
+        is_main_frame, details.is_in_page, params.url, std::string(), false,
+        params.frame_id);
     load_details.set_transition_type(params.transition);
     // Whether or not a page transition was triggered by going backward or
     // forward in the history is only stored in the navigation controller's
     // entry list.
     if (did_navigate &&
         (controller_.GetActiveEntry()->transition_type() &
             PageTransition::FORWARD_BACK)) {
       load_details.set_transition_type(
           params.transition | PageTransition::FORWARD_BACK);
     }
@@ skipping 826 matching lines @@
   AddInfoBar(new SavePasswordInfoBarDelegate(this, form_to_save));
 }
 
 Profile* TabContents::GetProfileForPasswordManager() {
   return profile();
 }
 
 bool TabContents::DidLastPageLoadEncounterSSLErrors() {
   return controller().ssl_manager()->ProcessedSSLErrorFromRequest();
 }