Submit buffered data use reports when Chromium is backgrounded

chrome/browser/android/data_usage/external_data_use_observer.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/external_data_use_observer.h"
 
 #include <utility>
 
 #include "base/containers/hash_tables.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 128 matching lines @@
       ui_task_runner_(ui_task_runner),
       previous_report_time_(base::Time::Now()),
       last_matching_rules_fetch_time_(base::TimeTicks::Now()),
       external_data_use_observer_bridge_(new ExternalDataUseObserverBridge()),
       total_bytes_buffered_(0),
       fetch_matching_rules_duration_(
           base::TimeDelta::FromSeconds(GetFetchMatchingRulesDurationSeconds())),
       data_use_report_min_bytes_(GetMinBytes()),
       data_report_submit_timeout_(
           base::TimeDelta::FromMilliseconds(GetDataReportSubmitTimeoutMsec())),
+#if defined(OS_ANDROID)
+      app_state_listener_(new base::android::ApplicationStatusListener(
+          base::Bind(&ExternalDataUseObserver::OnApplicationStateChange,
+                     base::Unretained(this)))),
+#endif
       registered_as_data_use_observer_(false),
       weak_factory_(this) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(data_use_aggregator_);
   DCHECK(io_task_runner);
   DCHECK(ui_task_runner_);
   DCHECK(last_data_report_submitted_ticks_.is_null());
 
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&DataUseTabModel::InitOnUIThread,
@@ skipping 38 matching lines @@
     RecordDataUsageReportSubmission(DATAUSAGE_REPORT_SUBMISSION_SUCCESSFUL,
                                     pending_report_bytes_);
   } else {
     RecordDataUsageReportSubmission(DATAUSAGE_REPORT_SUBMISSION_FAILED,
                                     pending_report_bytes_);
   }
 
   last_data_report_submitted_ticks_ = base::TimeTicks();
   pending_report_bytes_ = 0;
 
-  SubmitBufferedDataUseReport();
+  SubmitBufferedDataUseReport(false);
 }
 
+#if defined(OS_ANDROID)
+void ExternalDataUseObserver::OnApplicationStateChange(
+    base::android::ApplicationState new_state) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (new_state == base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES)
+    SubmitBufferedDataUseReport(true);
+}
+#endif
+
 void ExternalDataUseObserver::OnDataUse(const data_usage::DataUse& data_use) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(registered_as_data_use_observer_);
 
   const base::TimeTicks now_ticks = base::TimeTicks::Now();
   const base::Time now_time = base::Time::Now();
 
   // If the time when the matching rules were last fetched is more than
   // |fetch_matching_rules_duration_|, fetch them again.
   if (now_ticks - last_matching_rules_fetch_time_ >=
@@ skipping 43 matching lines @@
     const base::Time& start_time,
     const base::Time& end_time,
     const std::string* label,
     bool label_applied) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!label_applied)
     return;
 
   BufferDataUseReport(data_use, *label, start_time, end_time);
-  SubmitBufferedDataUseReport();
+  SubmitBufferedDataUseReport(false);
 }
 
 void ExternalDataUseObserver::BufferDataUseReport(
     const data_usage::DataUse& data_use,
     const std::string& label,
     const base::Time& start_time,
     const base::Time& end_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!label.empty());
   DCHECK_LE(0, data_use.rx_bytes);
@@ skipping 29 matching lines @@
     buffered_data_reports_.erase(it);
     buffered_data_reports_.insert(
         std::make_pair(data_use_report_key, merged_report));
   }
   total_bytes_buffered_ += (data_use.rx_bytes + data_use.tx_bytes);
 
   DCHECK_LT(0U, buffered_data_reports_.size());
   DCHECK_LE(buffered_data_reports_.size(), kMaxBufferSize);
 }
 
-void ExternalDataUseObserver::SubmitBufferedDataUseReport() {
+void ExternalDataUseObserver::SubmitBufferedDataUseReport(bool immediate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const base::TimeTicks ticks_now = base::TimeTicks::Now();
 
   // Return if a data use report has been pending for less than
   // |data_report_submit_timeout_| duration.
   if (!last_data_report_submitted_ticks_.is_null() &&
       ticks_now - last_data_report_submitted_ticks_ <
           data_report_submit_timeout_) {
     return;
   }
 
   if (buffered_data_reports_.empty())
     return;
 
-  if (total_bytes_buffered_ < data_use_report_min_bytes_)
+  if (!immediate && total_bytes_buffered_ < data_use_report_min_bytes_)
     return;
 
   if (!last_data_report_submitted_ticks_.is_null()) {
     // Mark the pending DataUsage report as timed out.
     RecordDataUsageReportSubmission(DATAUSAGE_REPORT_SUBMISSION_TIMED_OUT,
                                     pending_report_bytes_);
     pending_report_bytes_ = 0;
     last_data_report_submitted_ticks_ = base::TimeTicks();
   }
 
@@ skipping 68 matching lines @@
   size_t hash = 1;
   hash = hash * 23 + hash_function(k.label);
   hash = hash * 43 + k.connection_type;
   hash = hash * 83 + hash_function(k.mcc_mnc);
   return hash;
 }
 
 }  // namespace android
 
 }  // namespace chrome