Batch data use objects in ExternalDataUseObserver

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/field_trial.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 49 matching lines @@
       data_use_tab_model_(new DataUseTabModel(
           base::Bind(&ExternalDataUseObserverBridge::FetchMatchingRules,
                      base::Unretained(external_data_use_observer_bridge_)),
           base::Bind(
               &ExternalDataUseObserverBridge::ShouldRegisterAsDataUseObserver,
               base::Unretained(external_data_use_observer_bridge_)))),
       external_data_use_reporter_(
           new ExternalDataUseReporter(kExternalDataUseObserverFieldTrial,
                                       data_use_tab_model_,
                                       external_data_use_observer_bridge_)),
+      io_task_runner_(io_task_runner),
       ui_task_runner_(ui_task_runner),
       last_matching_rules_fetch_time_(base::TimeTicks::Now()),
       fetch_matching_rules_duration_(
           base::TimeDelta::FromSeconds(GetFetchMatchingRulesDurationSeconds())),
       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(io_task_runner_);
   DCHECK(ui_task_runner_);
 
   // Initialize the ExternalDataUseReporter object. It is okay to use
   // base::Unretained here since |external_data_use_reporter_| is owned by
   // |this|, and is destroyed on UI thread when |this| is destroyed.
   ui_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ExternalDataUseReporter::InitOnUIThread,
                             base::Unretained(external_data_use_reporter_)));
 
   // Initialize the ExternalDataUseObserverBridge object. It is okay to use
   // base::Unretained here since |external_data_use_observer_bridge_| is owned
   // by |this|, and is destroyed on UI thread when |this| is destroyed.
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ExternalDataUseObserverBridge::Init,
                  base::Unretained(external_data_use_observer_bridge_),
-                 io_task_runner, GetWeakPtr(), data_use_tab_model_));
+                 io_task_runner_, GetWeakPtr(), data_use_tab_model_));
 }
 
 ExternalDataUseObserver::~ExternalDataUseObserver() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (registered_as_data_use_observer_)
     data_use_aggregator_->RemoveObserver(this);
 
   // Delete |external_data_use_reporter_| on the UI thread.
   // |external_data_use_reporter_| should be deleted before
@@ skipping 13 matching lines @@
                                    external_data_use_observer_bridge_)) {
     NOTIMPLEMENTED()
         << " ExternalDataUseObserverBridge was not deleted successfully";
   }
 }
 
 void ExternalDataUseObserver::OnDataUse(const data_usage::DataUse& data_use) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(registered_as_data_use_observer_);
 
+  if (!data_use_list_) {
+    data_use_list_.reset(new std::deque<const data_usage::DataUse>());
+    // Post a task to the same IO thread, that will get invoked when some of the
+    // data use objects are batched.
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&ExternalDataUseObserver::OnDataUseBatchComplete,
+                              GetWeakPtr()));
+  }
+
+  data_use_list_->push_back(data_use);
+}
+
+void ExternalDataUseObserver::OnDataUseBatchComplete() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(data_use_list_);
+
   const base::TimeTicks now_ticks = base::TimeTicks::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_ >=
       fetch_matching_rules_duration_) {
     FetchMatchingRules();
   }
 
   // It is okay to use base::Unretained here since |external_data_use_reporter_|
   // is owned by |this|, and is destroyed on UI thread when |this| is destroyed.
   ui_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&ExternalDataUseReporter::OnDataUse,
-                 base::Unretained(external_data_use_reporter_), data_use));
+      FROM_HERE, base::Bind(&ExternalDataUseReporter::OnDataUse,
+                            base::Unretained(external_data_use_reporter_),
+                            base::Passed(&data_use_list_)));
+  DCHECK(!data_use_list_);
 }
 
 void ExternalDataUseObserver::OnReportDataUseDone(bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // It is okay to use base::Unretained here since |external_data_use_reporter_|
   // is owned by |this|, and is destroyed on UI thread when |this| is destroyed.
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ExternalDataUseReporter::OnReportDataUseDone,
@@ skipping 35 matching lines @@
 }
 
 DataUseTabModel* ExternalDataUseObserver::GetDataUseTabModel() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return data_use_tab_model_;
 }
 
 }  // namespace android
 
 }  // namespace chrome