Add EffectiveConnectionType enum to the system profile proto

chrome/browser/metrics/chrome_metrics_service_client.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/metrics/chrome_metrics_service_client.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "base/metrics/persistent_histogram_allocator.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string16.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_brand.h"
+#include "chrome/browser/io_thread.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 #include "chrome/browser/metrics/https_engagement_metrics_provider.h"
 #include "chrome/browser/metrics/metrics_reporting_state.h"
 #include "chrome/browser/metrics/sampling_metrics_provider.h"
 #include "chrome/browser/metrics/subprocess_metrics_provider.h"
 #include "chrome/browser/metrics/time_ticks_experiment_win.h"
 #include "chrome/browser/sync/chrome_sync_client.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/channel_info.h"
@@ skipping 73 matching lines @@
 #include "third_party/crashpad/crashpad/client/crashpad_info.h"
 #endif
 
 #if !defined(OS_CHROMEOS)
 #include "chrome/browser/signin/chrome_signin_status_metrics_provider_delegate.h"
 #include "components/signin/core/browser/signin_status_metrics_provider.h"
 #endif  // !defined(OS_CHROMEOS)
 
 namespace {
 
+// Returns the network quality estimator. Runs on IO thread.
+net::NetworkQualityEstimator* GetNetworkQualityEstimatorOnIOThread(
+    IOThread* io_thread) {
+  if (!io_thread)
+    return nullptr;
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  return io_thread->globals()->network_quality_estimator.get();
+}
+
 // This specifies the amount of time to wait for all renderers to send their
 // data.
 const int kMaxHistogramGatheringWaitDuration = 60000;  // 60 seconds.
 
 // Needs to be kept in sync with the writer in
 // third_party/crashpad/crashpad/handler/handler_main.cc.
 const char kCrashpadHistogramAllocatorName[] = "CrashpadMetrics";
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 // The stream type assigned to the minidump stream that holds the serialized
@@ skipping 141 matching lines @@
       plugin_metrics_provider_(nullptr),
 #endif
 #if defined(OS_WIN)
       google_update_metrics_provider_(nullptr),
       watcher_metrics_provider_(nullptr),
       antivirus_metrics_provider_(nullptr),
 #endif
       drive_metrics_provider_(nullptr),
       start_time_(base::TimeTicks::Now()),
       has_uploaded_profiler_data_(false),
+      network_metrics_provider_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RecordCommandLineMetrics();
   RegisterForNotifications();
 }
 
 ChromeMetricsServiceClient::~ChromeMetricsServiceClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::GlobalHistogramAllocator* allocator =
       base::GlobalHistogramAllocator::Get();
@@ skipping 267 matching lines @@
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new SubprocessMetricsProvider()));
 
   // Register metrics providers.
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new ExtensionsMetricsProvider(metrics_state_manager_)));
 #endif
+
+  std::unique_ptr<metrics::NetworkMetricsProvider> network_metrics_provider(
+      new metrics::NetworkMetricsProvider(
+          content::BrowserThread::GetBlockingPool()));
+
+  network_metrics_provider_ = network_metrics_provider.get();
+
+  // Get the network quality estimator on the IO thread, and provide it to the
+  // |network_metrics_provider|.
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(GetNetworkQualityEstimatorOnIOThread,
+                 g_browser_process->io_thread()),
+      base::Bind(&ChromeMetricsServiceClient::ProvideNetworkQualityEstimator,
+                 weak_ptr_factory_.GetWeakPtr()));
+
   metrics_service_->RegisterMetricsProvider(
-      std::unique_ptr<metrics::MetricsProvider>(
-          new metrics::NetworkMetricsProvider(
-              content::BrowserThread::GetBlockingPool())));
+      std::move(network_metrics_provider));
 
   // Currently, we configure OmniboxMetricsProvider to not log events to UMA
   // if there is a single incognito session visible. In the future, it may
   // be worth revisiting this to still log events from non-incognito sessions.
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider(
           base::Bind(&chrome::IsIncognitoSessionActive))));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new ChromeStabilityMetricsProvider(local_state)));
@@ skipping 303 matching lines @@
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return metrics::IsCellularLogicEnabled();
 }
+
+void ChromeMetricsServiceClient::ProvideNetworkQualityEstimator(
+    net::NetworkQualityEstimator* network_quality_estimator) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Provide the |network_quality_estimator| and the thread on which

[RyanSturm, 2016/12/28 21:53:11]

nit: s/the thread/the taskrunner for the thread/

[tbansal1, 2017/01/03 17:25:13]

Done.

+  // |network_quality_estimator| runs to |network_metrics_provider_|.
+  network_metrics_provider_->ProvideNetworkQualityEstimator(
+      network_quality_estimator, content::BrowserThread::GetTaskRunnerForThread(
+                                     content::BrowserThread::IO));
+}