Buffer UI navigation events in DataUseTabModel until rule fetch

chrome/browser/android/data_usage/data_use_tab_model.cc

 // Copyright 2015 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/android/data_usage/data_use_tab_model.h"
 
 #include <stdint.h>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 22 matching lines @@
 // overridden by the field trial.
 const uint32_t kDefaultClosedTabExpirationDurationSeconds = 30;  // 30 seconds.
 const uint32_t kDefaultOpenTabExpirationDurationSeconds =
     60 * 60 * 24 * 5;  // 5 days.
 
 // Default expiration duration in seconds of a matching rule, used when
 // expiration time is not specified.
 const uint32_t kDefaultMatchingRuleExpirationDurationSeconds =
     60 * 60 * 24;  // 24 hours.
 
+// Default maximum limit imposed for the initial UI navigation event buffer.
+// Once this limit is reached, the buffer will be cleared.
+const uint32_t kDefaultMaxNavigationEventsBuffered = 100;
+
 const char kUMAExpiredInactiveTabEntryRemovalDurationHistogram[] =
     "DataUsage.TabModel.ExpiredInactiveTabEntryRemovalDuration";
 const char kUMAExpiredActiveTabEntryRemovalDurationHistogram[] =
     "DataUsage.TabModel.ExpiredActiveTabEntryRemovalDuration";
 const char kUMAUnexpiredTabEntryRemovalDurationHistogram[] =
     "DataUsage.TabModel.UnexpiredTabEntryRemovalDuration";
 
 // Returns true if |tab_id| is a valid tab ID.
 bool IsValidTabID(SessionID::id_type tab_id) {
   return tab_id >= 0;
@@ skipping 73 matching lines @@
 namespace chrome {
 
 namespace android {
 
 DataUseTabModel::DataUseTabModel()
     : max_tab_entries_(GetMaxTabEntries()),
       max_sessions_per_tab_(GetMaxSessionsPerTab()),
       closed_tab_expiration_duration_(GetClosedTabExpirationDuration()),
       open_tab_expiration_duration_(GetOpenTabExpirationDuration()),
       is_control_app_installed_(false),
+      data_use_ui_navigations_(new std::vector<DataUseUINavigationEvent>()),
       weak_factory_(this) {
   // Detach from current thread since rest of DataUseTabModel lives on the UI
   // thread and the current thread may not be UI thread..
   thread_checker_.DetachFromThread();
 }
 
 DataUseTabModel::~DataUseTabModel() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
@@ skipping 13 matching lines @@
       new DataUseMatcher(GetWeakPtr(), external_data_use_observer_bridge,
                          GetDefaultMatchingRuleExpirationDuration()));
 }
 
 void DataUseTabModel::OnNavigationEvent(SessionID::id_type tab_id,
                                         TransitionType transition,
                                         const GURL& url,
                                         const std::string& package) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsValidTabID(tab_id));
+
+  if (data_use_ui_navigations_) {
+    // Buffer the navigation event for later processing.
+    DataUseUINavigationEvent ui_event(tab_id, transition, url, package);
+    data_use_ui_navigations_->push_back(ui_event);

[tbansal1, 2016/03/29 16:20:41]

Just push directly without creating temp. variable |ui_event|?

[Raj, 2016/03/29 18:03:20]

Done.

+
+    if (data_use_ui_navigations_->size() >=
+        kDefaultMaxNavigationEventsBuffered) {
+      ProcessBufferedNavigationEvents();
+    }
+    return;
+  }
+
   std::string current_label, new_label;
   bool is_package_match;
 
   if (is_control_app_installed_ && !data_use_matcher_->HasValidRules())
     data_use_matcher_->FetchMatchingRules();
 
   GetCurrentAndNewLabelForNavigationEvent(tab_id, transition, url, package,
                                           &current_label, &new_label,
                                           &is_package_match);
   if (!current_label.empty() && new_label.empty()) {
@@ skipping 72 matching lines @@
     const std::vector<std::string>& label) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Fetch rule requests could be started when control app was installed, and
   // the response could be received when control app was uninstalled. Ignore
   // these spurious rule fetch responses.
   if (!is_control_app_installed_)
     return;
   data_use_matcher_->RegisterURLRegexes(app_package_name, domain_path_regex,
                                         label);
+  ProcessBufferedNavigationEvents();
 }
 
 void DataUseTabModel::OnControlAppInstallStateChange(
     bool is_control_app_installed) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(is_control_app_installed_, is_control_app_installed);
   DCHECK(data_use_matcher_);
 
   is_control_app_installed_ = is_control_app_installed;
   std::vector<std::string> empty;
   if (!is_control_app_installed_) {
-    // Clear rules.
+    // Clear rules, and process the buffered UI navigation events.
     data_use_matcher_->RegisterURLRegexes(empty, empty, empty);
+    ProcessBufferedNavigationEvents();
   } else {
     // Fetch the matching rules when the app is installed.
     data_use_matcher_->FetchMatchingRules();
   }
 }
 
 base::TimeTicks DataUseTabModel::NowTicks() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return tick_clock_->NowTicks();
 }
@@ skipping 168 matching lines @@
     DCHECK(oldest_tab_entry_iterator != active_tabs_.end());
     UMA_HISTOGRAM_CUSTOM_TIMES(
         kUMAUnexpiredTabEntryRemovalDurationHistogram,
         NowTicks() -
             oldest_tab_entry_iterator->second.GetLatestStartOrEndTime(),
         base::TimeDelta::FromMinutes(1), base::TimeDelta::FromHours(1), 50);
     active_tabs_.erase(oldest_tab_entry_iterator);
   }
 }
 
+void DataUseTabModel::ProcessBufferedNavigationEvents() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!data_use_ui_navigations_)
+    return;
+  // Move the ownership of vector managed by |data_use_ui_navigations_| and
+  // release it, so that navigation events will be processed immediately.
+  const auto tmp_data_use_ui_navigations_ = std::move(data_use_ui_navigations_);
+  for (const auto& ui_event : *tmp_data_use_ui_navigations_.get()) {
+    OnNavigationEvent(ui_event.tab_id, ui_event.transition_type, ui_event.url,
+                      ui_event.package);
+  }
+}
+
 }  // namespace android
 
 }  // namespace chrome