Periodically remove old pending navigation entries.

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 "base/memory/ptr_util.h"
 #include "components/data_use_measurement/content/content_url_request_classifier.h"
 #include "components/data_use_measurement/core/data_use_recorder.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/data_use_measurement/core/url_request_classifier.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "net/url_request/url_request.h"
 
+namespace {
+const base::TimeDelta kDiscardPendingNavigationsThreshold =
+    base::TimeDelta::FromSeconds(5);
+const base::TimeDelta kDiscardPendingNavigationsInterval =
+    base::TimeDelta::FromSeconds(10);
+}
+
 namespace data_use_measurement {
-
 // static
 const void* ChromeDataUseAscriber::DataUseRecorderEntryAsUserData::
     kUserDataKey = static_cast<void*>(
         &ChromeDataUseAscriber::DataUseRecorderEntryAsUserData::kUserDataKey);
 
 ChromeDataUseAscriber::DataUseRecorderEntryAsUserData::
     DataUseRecorderEntryAsUserData(DataUseRecorderEntry entry)
     : entry_(entry) {}
 
 ChromeDataUseAscriber::DataUseRecorderEntryAsUserData::
     ~DataUseRecorderEntryAsUserData() {}
 
 ChromeDataUseAscriber::ChromeDataUseAscriber() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
 ChromeDataUseAscriber::~ChromeDataUseAscriber() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  DCHECK_EQ(0u, data_use_recorders_.size());
+  DCHECK_EQ(0u, render_frame_data_use_map_.size());
+  DCHECK_EQ(pending_navigation_data_use_map_.size(),
+            data_use_recorders_.size());
 }
 
 DataUseRecorder* ChromeDataUseAscriber::GetDataUseRecorder(
     net::URLRequest* request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   return nullptr;
 }
 
 void ChromeDataUseAscriber::OnBeforeUrlRequest(net::URLRequest* request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
@@ skipping 39 matching lines @@
       request->GetUserData(DataUseRecorderEntryAsUserData::kUserDataKey));
   if (user_data)
     return;
 
   DataUseRecorderEntry entry = data_use_recorders_.insert(
       data_use_recorders_.end(), base::MakeUnique<DataUseRecorder>());
   request->SetUserData(DataUseRecorderEntryAsUserData::kUserDataKey,
                        new DataUseRecorderEntryAsUserData(entry));
   pending_navigation_data_use_map_.insert(
       std::make_pair(request_info->GetGlobalRequestID(), entry));
+
+  DeleteOldPendingNavigationEntries(base::Time::Now());
 }
 
 void ChromeDataUseAscriber::OnUrlRequestDestroyed(net::URLRequest* request) {
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(request);
   content::ResourceType resource_type = request_info
                                             ? request_info->GetResourceType()
                                             : content::RESOURCE_TYPE_LAST_TYPE;
   if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
     // If request was not successful, then ReadyToCommitNavigation will not be
@@ skipping 74 matching lines @@
     pending_navigation_data_use_map_.erase(navigation_iter);
     data_use_recorders_.erase(entry);
   }
 }
 
 std::unique_ptr<URLRequestClassifier>
 ChromeDataUseAscriber::CreateURLRequestClassifier() const {
   return base::MakeUnique<ContentURLRequestClassifier>();
 }
 
+void ChromeDataUseAscriber::DeleteOldPendingNavigationEntries(base::Time now) {
+  if (last_pending_navigations_discard_time_ >
+      now + kDiscardPendingNavigationsInterval) {
+    return;
+  }
+  last_pending_navigations_discard_time_ = now;
+
+  for (auto iter = pending_navigation_data_use_map_.begin();
+       iter != pending_navigation_data_use_map_.end();) {
+    DataUseRecorderEntry entry = iter->second;
+    DataUseRecorder* recorder = (*entry).get();
+    const DataUse& data_use = (*entry)->data_use();
+    if (recorder->IsDataUseComplete() &&
+        data_use.start_time() <= now - kDiscardPendingNavigationsThreshold) {
+      data_use_recorders_.erase(entry);
+      iter = pending_navigation_data_use_map_.erase(iter);
+    } else {
+      iter++;
+    }
+  }
+}
+
 }  // namespace data_use_measurement