Expose API to store and load data usage stats from UI task runner.

components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc

Index: components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc
diff --git a/components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc b/components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc
index a80ff3e1484596af6036086e0a831ea5f398ae1a..d9e918a3c57c35f75dd20f0fd2f685c743e1aa24 100644
--- a/components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc
+++ b/components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc
@@ -5,17 +5,21 @@
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_service.h"
 
 #include "base/bind.h"
+#include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/sequenced_task_runner.h"
+#include "base/task_runner_util.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_service_observer.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
+#include "components/data_reduction_proxy/core/browser/data_store.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_event_store.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_pref_names.h"
+#include "components/data_reduction_proxy/proto/data_store.pb.h"
 
 namespace data_reduction_proxy {
 
@@ -24,19 +28,29 @@ DataReductionProxyService::DataReductionProxyService(
     DataReductionProxySettings* settings,
     PrefService* prefs,
     net::URLRequestContextGetter* request_context_getter,
-    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    scoped_ptr<DataStore> store,
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& db_task_runner)
     : url_request_context_getter_(request_context_getter),
       settings_(settings),
       prefs_(prefs),
+      db_data_owner_(new DBDataOwner(store.Pass())),
       io_task_runner_(io_task_runner),
+      db_task_runner_(db_task_runner),
       initialized_(false),
       weak_factory_(this) {
   DCHECK(settings);
   compression_stats_ = compression_stats.Pass();
+  compression_stats_->set_data_reduction_proxy_service(this);

[jeremyim, 2015/07/14 23:06:03]

Can we conditionally create the compression_stats here based on a non-null prefs
object? This would mean passing in the ui_task_runner here, but would mean that
DRPCompressionStats could receive the service object in the constructor instead
of a set method.

[Not at Google. Contact bengr, 2015/07/15 00:08:17]

Done.

   event_store_.reset(new DataReductionProxyEventStore());
+  db_task_runner_->PostTask(FROM_HERE,
+                            base::Bind(&DBDataOwner::InitializeOnDBThread,
+                                       db_data_owner_->GetWeakPtr()));
 }
 
 DataReductionProxyService::~DataReductionProxyService() {
+  DCHECK(CalledOnValidThread());
+  db_task_runner_->DeleteSoon(FROM_HERE, db_data_owner_.release());
 }
 
 void DataReductionProxyService::SetIOData(
@@ -70,7 +84,8 @@ void DataReductionProxyService::Shutdown() {
 
 void DataReductionProxyService::EnableCompressionStatisticsLogging(
     PrefService* prefs,
-    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     const base::TimeDelta& commit_delay) {
   DCHECK(CalledOnValidThread());
   DCHECK(!compression_stats_);
@@ -242,6 +257,25 @@ void DataReductionProxyService::RetrieveConfig() {
       base::Bind(&DataReductionProxyIOData::RetrieveConfig, io_data_));
 }
 
+void DataReductionProxyService::LoadCurrentDataUsageBucket(
+    const OnLoadDataUsageBucketCallback& onLoadDataUsageBucket) {
+  scoped_ptr<DataUsageBucket> bucket(new DataUsageBucket());
+  DataUsageBucket* bucket_ptr = bucket.get();
+  db_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&DBDataOwner::LoadCurrentDataUsageBucket,
+                 db_data_owner_->GetWeakPtr(), base::Unretained(bucket_ptr)),
+      base::Bind(onLoadDataUsageBucket, base::Passed(&bucket)));
+}
+
+void DataReductionProxyService::StoreCurrentDataUsageBucket(
+    scoped_ptr<DataUsageBucket> current) {
+  db_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&DBDataOwner::StoreCurrentDataUsageBucket,
+                 db_data_owner_->GetWeakPtr(), base::Passed(&current)));
+}
+
 void DataReductionProxyService::AddObserver(
     DataReductionProxyServiceObserver* observer) {
   DCHECK(CalledOnValidThread());