Pipe local_state into ChromeDataUseMeasurement.

This removes the dependency ChromeDataUseMeasurement has on
g_browser_process (when kNetworkService is enabled) and fixes a
crash when starting in service-manager-only mode.

Bug: 902791
Change-Id: I0ed11f4735f4494247a7c17767b53aab695d0f14
Reviewed-on: https://chromium-review.googlesource.com/c/1334334Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Min Qin <qinmin@chromium.org>
Reviewed-by: rajendrant <rajendrant@chromium.org>
Commit-Queue: Henrique Nakashima <hnakashima@chromium.org>
Cr-Commit-Position: refs/heads/master@{#612421}

chrome/browser/chrome_content_browser_client.cc

@@ -4698,11 +4698,22 @@ void ChromeContentBrowserClient::OnNetworkServiceCreated(
     network::mojom::NetworkService* network_service) {
   if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
     return;
+
+  PrefService* local_state;
+  if (g_browser_process) {
+    DCHECK(g_browser_process->local_state());
+    local_state = g_browser_process->local_state();
+  } else {
+    DCHECK(chrome_feature_list_creator_->local_state());
+    local_state = chrome_feature_list_creator_->local_state();
+  }
+
+  if (!data_use_measurement::ChromeDataUseMeasurement::GetInstance())
+    data_use_measurement::ChromeDataUseMeasurement::CreateInstance(local_state);
+
   if (!SystemNetworkContextManager::GetInstance()) {
     DCHECK(!g_browser_process);
-    DCHECK(chrome_feature_list_creator_->local_state());
-    SystemNetworkContextManager::CreateInstance(
-        chrome_feature_list_creator_->local_state());
+    SystemNetworkContextManager::CreateInstance(local_state);
   }
   // Need to set up global NetworkService state before anything else uses it.
   SystemNetworkContextManager::GetInstance()->OnNetworkServiceCreated(

chrome/browser/data_use_measurement/chrome_data_use_ascriber.cc

@@ -583,8 +583,9 @@ ChromeDataUseAscriber::CreateNetworkDelegate(
     std::unique_ptr<net::NetworkDelegate> wrapped_network_delegate) {
   return std::make_unique<data_use_measurement::DataUseNetworkDelegate>(
       std::move(wrapped_network_delegate), this,
-      std::make_unique<ChromeDataUseMeasurement>(CreateURLRequestClassifier(),
-                                                 this, /*network_connection_tracker=*/nullptr));
+      std::make_unique<ChromeDataUseMeasurement>(
+          CreateURLRequestClassifier(), this,
+          /*network_connection_tracker=*/nullptr, /*local_state=*/nullptr));
 }
 
 std::unique_ptr<URLRequestClassifier>

chrome/browser/data_use_measurement/chrome_data_use_measurement.cc

@@ -30,54 +30,41 @@ namespace {
 // be deleted. When network service is disabled, this should always be null.
 ChromeDataUseMeasurement* g_chrome_data_use_measurement = nullptr;
 
-void UpdateMetricsUsagePrefs(int64_t total_bytes,
-                             bool is_cellular,
-                             bool is_metrics_service_usage) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  metrics::DataUseTracker::UpdateMetricsUsagePrefs(
-      base::saturated_cast<int>(total_bytes), is_cellular,
-      is_metrics_service_usage, g_browser_process->local_state());
-}
-
-// This function is for forwarding metrics usage pref changes to the metrics
-// service on the appropriate thread.
-// TODO(gayane): Reduce the frequency of posting tasks from IO to UI thread.
-void UpdateMetricsUsagePrefsOnUIThread(int64_t total_bytes,
-                                       bool is_cellular,
-                                       bool is_metrics_service_usage) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-  base::PostTaskWithTraits(
-      FROM_HERE, content::BrowserThread::UI,
-      base::BindOnce(UpdateMetricsUsagePrefs, total_bytes, is_cellular,
-                     is_metrics_service_usage));
-}
 }  // namespace
 
 // static
-ChromeDataUseMeasurement* ChromeDataUseMeasurement::GetInstance() {
+void ChromeDataUseMeasurement::CreateInstance(PrefService* local_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          !BrowserThread::IsThreadInitialized(BrowserThread::UI));
 
+  DCHECK(!g_chrome_data_use_measurement);
+
   // Do not create when NetworkService is disabled, since data use of URLLoader
   // is reported via the network delegate callbacks.
   if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
-    return nullptr;
+    return;
+
+  g_chrome_data_use_measurement = new ChromeDataUseMeasurement(
+      nullptr, nullptr, content::GetNetworkConnectionTracker(), local_state);
+}
+
+// static
+ChromeDataUseMeasurement* ChromeDataUseMeasurement::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
+         !BrowserThread::IsThreadInitialized(BrowserThread::UI));
 
-  if (!g_chrome_data_use_measurement) {
-    g_chrome_data_use_measurement = new ChromeDataUseMeasurement(
-        nullptr, nullptr, content::GetNetworkConnectionTracker());
-  }
   return g_chrome_data_use_measurement;
 }
 
 ChromeDataUseMeasurement::ChromeDataUseMeasurement(
     std::unique_ptr<URLRequestClassifier> url_request_classifier,
     DataUseAscriber* ascriber,
-    network::NetworkConnectionTracker* network_connection_tracker)
+    network::NetworkConnectionTracker* network_connection_tracker,
+    PrefService* local_state)
     : DataUseMeasurement(std::move(url_request_classifier),
                          ascriber,
-                         network_connection_tracker) {
+                         network_connection_tracker),
+      local_state_(local_state) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
@@ -131,4 +118,39 @@ void ChromeDataUseMeasurement::ReportNetworkServiceDataUse(
 #endif
 }
 
+void ChromeDataUseMeasurement::UpdateMetricsUsagePrefs(
+    int64_t total_bytes,
+    bool is_cellular,
+    bool is_metrics_service_usage) {
+  PrefService* local_state;
+  if (base::FeatureList::IsEnabled(network::features::kNetworkService)) {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    local_state = local_state_;
+  } else {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    local_state = g_browser_process->local_state();
+  }
+  DCHECK(local_state);
+
+  metrics::DataUseTracker::UpdateMetricsUsagePrefs(
+      base::saturated_cast<int>(total_bytes), is_cellular,
+      is_metrics_service_usage, local_state);
+}
+
+// This function is for forwarding metrics usage pref changes to the metrics
+// service on the appropriate thread.
+// TODO(gayane): Reduce the frequency of posting tasks from IO to UI thread.
+void ChromeDataUseMeasurement::UpdateMetricsUsagePrefsOnUIThread(
+    int64_t total_bytes,
+    bool is_cellular,
+    bool is_metrics_service_usage) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  base::PostTaskWithTraits(
+      FROM_HERE, content::BrowserThread::UI,
+      base::BindOnce(&ChromeDataUseMeasurement::UpdateMetricsUsagePrefs,
+                     base::Unretained(this), total_bytes, is_cellular,
+                     is_metrics_service_usage));
+}
+
 }  // namespace data_use_measurement

chrome/browser/data_use_measurement/chrome_data_use_measurement.h

@@ -11,18 +11,22 @@
 #include "components/data_use_measurement/core/data_use_measurement.h"
 #include "components/data_use_measurement/core/url_request_classifier.h"
 
+class PrefService;
+
 namespace data_use_measurement {
 
 class DataUseAscriber;
 
 class ChromeDataUseMeasurement : public DataUseMeasurement {
  public:
+  static void CreateInstance(PrefService* local_state);
   static ChromeDataUseMeasurement* GetInstance();
 
   ChromeDataUseMeasurement(
       std::unique_ptr<URLRequestClassifier> url_request_classifier,
       DataUseAscriber* ascriber,
-      network::NetworkConnectionTracker* network_connection_tracker);
+      network::NetworkConnectionTracker* network_connection_tracker,
+      PrefService* local_state);
 
   void UpdateDataUseToMetricsService(int64_t total_bytes,
                                      bool is_cellular,
@@ -35,6 +39,15 @@ class ChromeDataUseMeasurement : public DataUseMeasurement {
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeDataUseMeasurement);
+
+  void UpdateMetricsUsagePrefs(int64_t total_bytes,
+                               bool is_cellular,
+                               bool is_metrics_service_usage);
+  void UpdateMetricsUsagePrefsOnUIThread(int64_t total_bytes,
+                                         bool is_cellular,
+                                         bool is_metrics_service_usage);
+
+  PrefService* local_state_ = nullptr;
 };
 
 }  // namespace data_use_measurement

chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.cc

@@ -220,6 +220,10 @@ void DataReductionProxyChromeSettings::InitDataReductionProxySettings(
   base::TimeDelta commit_delay = base::TimeDelta::FromMinutes(60);
 #endif
 
+  if (!data_use_measurement::ChromeDataUseMeasurement::GetInstance()) {
+    data_use_measurement::ChromeDataUseMeasurement::CreateInstance(
+        g_browser_process->local_state());
+  }
   std::unique_ptr<data_reduction_proxy::DataReductionProxyService> service =
       std::make_unique<data_reduction_proxy::DataReductionProxyService>(
           this, profile_prefs, request_context_getter, url_loader_factory,

content/browser/network_service_instance.cc

@@ -199,7 +199,8 @@ void FlushNetworkServiceInstanceForTesting() {
 }
 
 network::NetworkConnectionTracker* GetNetworkConnectionTracker() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
+         !BrowserThread::IsThreadInitialized(BrowserThread::UI));
   if (!g_network_connection_tracker) {
     g_network_connection_tracker = new network::NetworkConnectionTracker(
         base::BindRepeating(&BindNetworkChangeManagerRequest));