LevelDB storage for data reduction proxy to store data usage stats.

chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.cc

 // Copyright 2014 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/net/spdyproxy/data_reduction_proxy_chrome_settings.h"
 
 #include <string>
 
 #include "base/base64.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config.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.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_store_impl.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "net/base/host_port_pair.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_list.h"
 #include "net/proxy/proxy_server.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 // Assume that any proxy host ending with this suffix is a Data Reduction Proxy.
@@ skipping 131 matching lines @@
 }
 
 void DataReductionProxyChromeSettings::Shutdown() {
   data_reduction_proxy_service()->Shutdown();
 }
 
 void DataReductionProxyChromeSettings::InitDataReductionProxySettings(
     data_reduction_proxy::DataReductionProxyIOData* io_data,
     PrefService* profile_prefs,
     net::URLRequestContextGetter* request_context_getter,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
+    const base::FilePath& profile_path,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& db_task_runner) {
 #if defined(OS_ANDROID) || defined(OS_IOS)
   // On mobile we write Data Reduction Proxy prefs directly to the pref service.
   // On desktop we store Data Reduction Proxy prefs in memory, writing to disk
   // every 60 minutes and on termination. Shutdown hooks must be added for
   // Android and iOS in order for non-zero delays to be supported.
   // (http://crbug.com/408264)
   base::TimeDelta commit_delay = base::TimeDelta();
 #else
   base::TimeDelta commit_delay = base::TimeDelta::FromMinutes(60);
 #endif
 
+  scoped_refptr<data_reduction_proxy::DataReductionProxyStoreImpl> store(

[bengr, 2015/06/25 23:22:54]

So the store is created on UI and initialzed on DB? Can DB outlive UI?

Also, our UI-to-IO thread hopping code in in DRPService. It might make sense to
put our UI-to-DB posts there too.

[Not at Google. Contact bengr, 2015/06/29 20:53:26]

UI thread outlives DB thread.

For DB thread hops we don't use weak pointers so a similar structure does not
get anything functionally.

We could do this for stylistic reasons, but DRPService seems like the wrong
place. I could add a new class -- DRPDBService say -- which will post to DB
thread. However, currently compression stats and here are the only places such
posts would happen. How about waiting until there is a usecase outside of
compression stats?

+      new data_reduction_proxy::DataReductionProxyStoreImpl(profile_path));
+  db_task_runner->PostTask(
+      FROM_HERE, base::Bind(&data_reduction_proxy::DataReductionProxyStoreImpl::
+                                InitializeOnDBThread,
+                            store));
+
   scoped_ptr<data_reduction_proxy::DataReductionProxyCompressionStats>
-      compression_stats = make_scoped_ptr(
+      compression_stats(
           new data_reduction_proxy::DataReductionProxyCompressionStats(
-              profile_prefs, ui_task_runner, commit_delay));
+              profile_prefs, ui_task_runner, db_task_runner, store,
+              commit_delay));
   scoped_ptr<data_reduction_proxy::DataReductionProxyService> service =
       make_scoped_ptr(new data_reduction_proxy::DataReductionProxyService(
           compression_stats.Pass(), this, profile_prefs, request_context_getter,
           io_data->io_task_runner()));
   data_reduction_proxy::DataReductionProxySettings::

[michaeln, 2015/06/26 20:15:00]

Lots of symbols in this method are prefixed with data_reduction_proxy:: which
makes it less readable. Looks like most of it boils down to constructing and
initializing a DataReductionProxyService instance. Would it make sense to push
more of this complicatd setup code into the data_reduction_proxy namespace? Or
maybe use some using statements to help with readability?

[Not at Google. Contact bengr, 2015/06/29 20:53:26]

The data_reduction_proxy code has actively moved away from "using". Could look
at moving this code, but out of scope for this cl.

       InitDataReductionProxySettings(profile_prefs, io_data, service.Pass());
   io_data->SetDataReductionProxyService(
       data_reduction_proxy_service()->GetWeakPtr());
 
   data_reduction_proxy::DataReductionProxySettings::
       SetCallbackToRegisterSyntheticFieldTrial(
           base::Bind(
               &ChromeMetricsServiceAccessor::RegisterSyntheticFieldTrial));
   SetDataReductionProxyAlternativeEnabled(
       data_reduction_proxy::params::IsIncludedInAlternativeFieldTrial());
@@ skipping 20 matching lines @@
 #elif defined(OS_OPENBSD)
   return data_reduction_proxy::Client::CHROME_OPENBSD;
 #elif defined(OS_SOLARIS)
   return data_reduction_proxy::Client::CHROME_SOLARIS;
 #elif defined(OS_QNX)
   return data_reduction_proxy::Client::CHROME_QNX;
 #else
   return data_reduction_proxy::Client::UNKNOWN;
 #endif
 }