Minor refactor to get rid of a friend association

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 120 matching lines @@
     const auto main_frame_key_iter = subframe_to_mainframe_map_.find(frame_key);
     if (main_frame_key_iter == subframe_to_mainframe_map_.end()) {
       return data_use_recorders_.end();
     }
     const auto frame_iter =
         main_render_frame_data_use_map_.find(main_frame_key_iter->second);
     if (frame_iter == main_render_frame_data_use_map_.end()) {
       return data_use_recorders_.end();
     }
 
-    const auto entry = frame_iter->second;
-    request->SetUserData(
-        DataUseRecorderEntryAsUserData::kUserDataKey,
-        base::MakeUnique<DataUseRecorderEntryAsUserData>(entry));
-    entry->AddPendingURLRequest(request);
-    return entry;
+    AscribeRecorderWithRequest(request, frame_iter->second);
+    return frame_iter->second;
   }
 
   // Create a new DataUseRecorder for all other requests.
   DataUseRecorderEntry entry = CreateNewDataUseRecorder(
       request,
       content::ResourceRequestInfo::OriginatedFromServiceWorker(request)
           ? DataUse::TrafficType::SERVICE_WORKER
           : DataUse::TrafficType::UNKNOWN);
   DataUse& data_use = entry->data_use();
   data_use.set_url(request->url());
@@ skipping 212 matching lines @@
     }
     return;
   }
   DataUseRecorderEntry old_frame_entry = frame_it->second;
   old_frame_entry->set_page_transition(page_transition);
   NotifyPageLoadCommit(old_frame_entry);
 
   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);
-    }
+    for (auto* request : entry->pending_url_requests())
+      AscribeRecorderWithRequest(request, old_frame_entry);
 
     entry->RemoveAllPendingURLRequests();
-
     data_use_recorders_.erase(entry);
   } else {
     if (old_frame_entry->IsDataUseComplete()) {
       NotifyDataUseCompleted(old_frame_entry);
       data_use_recorders_.erase(old_frame_entry);
 
       if (visible_main_render_frames_.find(mainframe) !=
           visible_main_render_frames_.end()) {
         entry->set_is_visible(true);
       }
@@ skipping 28 matching lines @@
 ChromeDataUseAscriber::CreateURLRequestClassifier() const {
   return base::MakeUnique<ContentURLRequestClassifier>();
 }
 
 ChromeDataUseAscriber::DataUseRecorderEntry
 ChromeDataUseAscriber::CreateNewDataUseRecorder(
     net::URLRequest* request,
     DataUse::TrafficType traffic_type) {
   DataUseRecorderEntry entry =
       data_use_recorders_.emplace(data_use_recorders_.end(), traffic_type);
-  if (request) {
-    entry->AddPendingURLRequest(request);
-    request->SetUserData(
-        DataUseRecorderEntryAsUserData::kUserDataKey,
-        base::MakeUnique<DataUseRecorderEntryAsUserData>(entry));
-  }
+  if (request)
+    AscribeRecorderWithRequest(request, entry);
   return entry;
 }
 
+void ChromeDataUseAscriber::AscribeRecorderWithRequest(
+    net::URLRequest* request,
+    DataUseRecorderEntry recorder) {
+  recorder->AddPendingURLRequest(request);
+  request->SetUserData(
+      DataUseRecorderEntryAsUserData::kUserDataKey,
+      base::MakeUnique<DataUseRecorderEntryAsUserData>(recorder));
+}
+
 void ChromeDataUseAscriber::WasShownOrHidden(int main_render_process_id,
                                              int main_render_frame_id,
                                              bool visible) {
   RenderFrameHostID main_render_frame_host_id(main_render_process_id,
                                               main_render_frame_id);
 
   auto frame_iter =
       main_render_frame_data_use_map_.find(main_render_frame_host_id);
   if (frame_iter != main_render_frame_data_use_map_.end())
     frame_iter->second->set_is_visible(visible);
@@ skipping 18 matching lines @@
       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