Support for transfer navigations in data use ascriber

chrome/browser/data_use_measurement/chrome_data_use_ascriber.cc

 // Copyright 2016 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/data_use_measurement/chrome_data_use_ascriber.h"
 
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/data_use_measurement/chrome_data_use_recorder.h"
@@ skipping 23 matching lines @@
 ChromeDataUseAscriber::DataUseRecorderEntryAsUserData::
     ~DataUseRecorderEntryAsUserData() {}
 
 ChromeDataUseAscriber::ChromeDataUseAscriber() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
 ChromeDataUseAscriber::~ChromeDataUseAscriber() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(subframe_to_mainframe_map_.empty());
+  DCHECK(pending_navigation_global_request_id_.empty());
   DCHECK(data_use_recorders_.empty());
 }
 
 ChromeDataUseRecorder* ChromeDataUseAscriber::GetOrCreateDataUseRecorder(
     net::URLRequest* request) {
   DataUseRecorderEntry entry = GetOrCreateDataUseRecorderEntry(request);
   return entry == data_use_recorders_.end() ? nullptr : &(*entry);
 }
 
 ChromeDataUseRecorder* ChromeDataUseAscriber::GetDataUseRecorder(
@@ skipping 190 matching lines @@
     auto frame_iter = main_render_frame_data_use_map_.find(key);
     DataUseRecorderEntry entry = frame_iter->second;
     if (entry->IsDataUseComplete()) {
       OnDataUseCompleted(entry);
       data_use_recorders_.erase(entry);
     }
     main_render_frame_data_use_map_.erase(frame_iter);
   }
   subframe_to_mainframe_map_.erase(key);
   visible_main_render_frames_.erase(key);
+  pending_navigation_global_request_id_.erase(key);
 }
 
 void ChromeDataUseAscriber::DidStartMainFrameNavigation(
     GURL gurl,
     int render_process_id,
     int render_frame_id,
     void* navigation_handle) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
 void ChromeDataUseAscriber::ReadyToCommitMainFrameNavigation(
-    GURL gurl,
     content::GlobalRequestID global_request_id,
     int render_process_id,
-    int render_frame_id,
-    bool is_same_page_navigation,
-    void* navigation_handle) {
+    int render_frame_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  pending_navigation_global_request_id_.insert(
+      std::make_pair(RenderFrameHostID(render_process_id, render_frame_id),
+                     global_request_id));
+}
+
+void ChromeDataUseAscriber::DidFinishNavigation(int render_process_id,
+                                                int render_frame_id,
+                                                GURL gurl,
+                                                bool is_same_page_navigation,
+                                                uint32_t page_transition) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
+  RenderFrameHostID mainframe(render_process_id, render_frame_id);
+
+  // Find the global request id of the pending navigation.
+  auto global_request_id =
+      pending_navigation_global_request_id_.find(mainframe);
+  DCHECK(global_request_id != pending_navigation_global_request_id_.end());
+
   // Find the DataUseRecorderEntry the frame is associated with
-  auto frame_it = main_render_frame_data_use_map_.find(
-      RenderFrameHostID(render_process_id, render_frame_id));
+  auto frame_it = main_render_frame_data_use_map_.find(mainframe);
 
   // Find the pending navigation entry.
   auto navigation_iter =
-      pending_navigation_data_use_map_.find(global_request_id);
+      pending_navigation_data_use_map_.find(global_request_id->second);
+  pending_navigation_global_request_id_.erase(global_request_id);
+
   // We might not find a navigation entry since the pending navigation may not
   // have caused any HTTP or HTTPS URLRequests to be made.
   if (navigation_iter == pending_navigation_data_use_map_.end()) {
     // No pending navigation entry to worry about. However, the old frame entry
     // must be removed from frame map, and possibly marked complete and deleted.
     if (frame_it != main_render_frame_data_use_map_.end()) {
       DataUseRecorderEntry old_frame_entry = frame_it->second;
+      old_frame_entry->set_page_transition(page_transition);
       main_render_frame_data_use_map_.erase(frame_it);
       if (old_frame_entry->IsDataUseComplete()) {
         OnDataUseCompleted(old_frame_entry);
         data_use_recorders_.erase(old_frame_entry);
       }
 
       // Add a new recorder to the render frame map to replace the deleted one.
       DataUseRecorderEntry entry = data_use_recorders_.emplace(
           data_use_recorders_.end());
-      std::pair<int, int> frame_key =
-          RenderFrameHostID(render_process_id, render_frame_id);
-      entry->set_main_frame_id(frame_key);
-      main_render_frame_data_use_map_.insert(std::make_pair(frame_key, entry));
+      entry->set_main_frame_id(mainframe);
+      main_render_frame_data_use_map_.insert(std::make_pair(mainframe, entry));
     }
     return;
   }
 
   DataUseRecorderEntry entry = navigation_iter->second;
   pending_navigation_data_use_map_.erase(navigation_iter);
-  entry->set_main_frame_id(
-      RenderFrameHostID(render_process_id, render_frame_id));
+  entry->set_main_frame_id(mainframe);
 
   // If the frame has already been deleted then mark this navigation as having
   // completed its data use.
   if (frame_it == main_render_frame_data_use_map_.end()) {
     if (entry->IsDataUseComplete()) {
+      entry->set_page_transition(page_transition);
       OnDataUseCompleted(entry);
       data_use_recorders_.erase(entry);
     }
     return;
   }
   DataUseRecorderEntry old_frame_entry = frame_it->second;
+  old_frame_entry->set_page_transition(page_transition);
+
   if (is_same_page_navigation) {
     old_frame_entry->MergeFrom(&(*entry));
 
     for (auto* request : entry->pending_url_requests()) {
       request->RemoveUserData(DataUseRecorderEntryAsUserData::kUserDataKey);
       request->SetUserData(
           DataUseRecorderEntryAsUserData::kUserDataKey,
           base::MakeUnique<DataUseRecorderEntryAsUserData>(old_frame_entry));
       old_frame_entry->AddPendingURLRequest(request);
     }
 
     entry->RemoveAllPendingURLRequests();
 
     data_use_recorders_.erase(entry);
   } else {
     // Navigation is not same page, so remove old entry from
     // |main_render_frame_data_use_map_|, possibly marking it complete.
     main_render_frame_data_use_map_.erase(frame_it);
     if (old_frame_entry->IsDataUseComplete()) {
       OnDataUseCompleted(old_frame_entry);
       data_use_recorders_.erase(old_frame_entry);
 
-      if (visible_main_render_frames_.find(
-              RenderFrameHostID(render_process_id, render_frame_id)) !=
+      if (visible_main_render_frames_.find(mainframe) !=
           visible_main_render_frames_.end()) {
         entry->set_is_visible(true);
       }
     }
 
     DataUse& data_use = entry->data_use();
 
     DCHECK(!data_use.url().is_valid() || data_use.url() == gurl)
         << "is valid: " << data_use.url().is_valid()
         << "; data_use.url(): " << data_use.url().spec()
         << "; gurl: " << gurl.spec();
     if (!data_use.url().is_valid()) {
       data_use.set_url(gurl);
     }
 
-    main_render_frame_data_use_map_.insert(std::make_pair(
-        RenderFrameHostID(render_process_id, render_frame_id), entry));
+    main_render_frame_data_use_map_.insert(std::make_pair(mainframe, entry));
   }
 }
 
-void ChromeDataUseAscriber::DidFinishNavigation(int render_process_id,
-                                                int render_frame_id,
-                                                uint32_t page_transition) {
-  auto frame_it = main_render_frame_data_use_map_.find(
-      RenderFrameHostID(render_process_id, render_frame_id));
-  if (frame_it != main_render_frame_data_use_map_.end()) {
-    frame_it->second->set_page_transition(page_transition);
-  }
-}
-
 void ChromeDataUseAscriber::OnDataUseCompleted(DataUseRecorderEntry entry) {
   // TODO(ryansturm): Notify observers that data use is complete.
 }
 
 std::unique_ptr<URLRequestClassifier>
 ChromeDataUseAscriber::CreateURLRequestClassifier() const {
   return base::MakeUnique<ContentURLRequestClassifier>();
 }
 
 ChromeDataUseAscriber::DataUseRecorderEntry
@@ skipping 24 matching lines @@
     visible_main_render_frames_.insert(main_render_frame_host_id);
   } else {
     visible_main_render_frames_.erase(main_render_frame_host_id);
   }
 }
 
 void ChromeDataUseAscriber::RenderFrameHostChanged(int old_render_process_id,
                                                    int old_render_frame_id,
                                                    int new_render_process_id,
                                                    int new_render_frame_id) {
-  if (visible_main_render_frames_.find(
-          RenderFrameHostID(old_render_process_id, old_render_frame_id)) !=
+  RenderFrameHostID old_frame(old_render_process_id, old_render_frame_id);
+  if (visible_main_render_frames_.find(old_frame) !=
       visible_main_render_frames_.end()) {
     WasShownOrHidden(new_render_process_id, new_render_frame_id, true);
   }
+  auto pending_navigation_iter =
+      pending_navigation_global_request_id_.find(old_frame);
+  if (pending_navigation_iter != pending_navigation_global_request_id_.end()) {
+    pending_navigation_global_request_id_.insert(std::make_pair(
+        RenderFrameHostID(new_render_process_id, new_render_frame_id),
+        pending_navigation_iter->second));
+    pending_navigation_global_request_id_.erase(pending_navigation_iter);
+  }
 }
 
 }  // namespace data_use_measurement