Enable UMA log uploads for cellular networks.

components/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 293 matching lines @@
   registry->RegisterBooleanPref(prefs::kStabilitySessionEndCompleted, true);
   registry->RegisterIntegerPref(prefs::kMetricsSessionID, -1);
 
   registry->RegisterListPref(prefs::kMetricsInitialLogs);
   registry->RegisterListPref(prefs::kMetricsOngoingLogs);
 
   registry->RegisterInt64Pref(prefs::kUninstallLaunchCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallMetricsUptimeSec, 0);
 }
 
+bool Test(){ return false;}

[Alexei Svitkine (slow), 2015/02/17 20:50:04]

Remove this. ;)

[gayane -on leave until 09-2017, 2015/02/18 00:30:35]

Done.

+
 MetricsService::MetricsService(MetricsStateManager* state_manager,
                                MetricsServiceClient* client,
                                PrefService* local_state)
     : log_manager_(local_state, kUploadLogAvoidRetransmitSize),
       histogram_snapshot_manager_(this),
       state_manager_(state_manager),
       client_(client),
       local_state_(local_state),
       clean_exit_beacon_(client->GetRegistryBackupKey(), local_state),
       recording_active_(false),
@@ skipping 19 matching lines @@
 
 MetricsService::~MetricsService() {
   DisableRecording();
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
   InitializeMetricsState();
 
   base::Closure callback = base::Bind(&MetricsService::StartScheduledUpload,
                                       self_ptr_factory_.GetWeakPtr());
-  scheduler_.reset(new MetricsReportingScheduler(callback));
+  base::Closure func =
+      base::Bind(&MetricsService::UpdateSchedulerConnectionType,

[Alexei Svitkine (slow), 2015/02/17 20:50:04]

Sorry, I don't like this structure.

I suggest the following:

void MetricsService::GetIsCellularConnection(bool* is_cellular_out) {
  is_cellular_out = IsCellularConnection();
}

and 

base::Callback<void(bool)> cellular_callback =
base::Bind(&MetricsService::GetIsCellularConnection,
self_ptr_factory_.GetWeakPtr());

Then, from the schedular, do:

bool is_cellular = false;
callback.Run(&is_cellular);
if (is_cellular) {
  ...
}

[gayane -on leave until 09-2017, 2015/02/18 00:30:35]

Done.

+                 self_ptr_factory_.GetWeakPtr());
+  scheduler_.reset(new MetricsReportingScheduler(callback, func));
 }
 
 void MetricsService::Start() {
   HandleIdleSinceLastTransmission(false);
   EnableRecording();
   EnableReporting();
 }
 
 bool MetricsService::StartIfMetricsReportingEnabled() {
   const bool enabled = state_manager_->IsMetricsReportingEnabled();
@@ skipping 892 matching lines @@
   DCHECK(IsSingleThreaded());
   local_state_->SetBoolean(path, value);
   RecordCurrentState(local_state_);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec,
                  base::Time::Now().ToTimeT());
 }
 
+void MetricsService::SetNetworkMetricsProvider(
+    metrics::NetworkMetricsProvider* network_metrics_provider) {
+  RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(network_metrics_provider));
+  network_metrics_provider_ = network_metrics_provider;
+}
+
+bool MetricsService::IsCellularConnection() {
+  SystemProfileProto::Network::ConnectionType connection_type =
+      network_metrics_provider_->GetConnectionType();
+
+  switch (connection_type) {
+    case SystemProfileProto_Network_ConnectionType_CONNECTION_2G:
+    case SystemProfileProto_Network_ConnectionType_CONNECTION_3G:
+    case SystemProfileProto_Network_ConnectionType_CONNECTION_4G:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void MetricsService::UpdateSchedulerConnectionType() {
+  scheduler_->SetConnectionType(IsCellularConnection());
+}
+
 }  // namespace metrics