Skip collection and upload of metrics if offline.

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 139 matching lines @@
 #include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_rotation_scheduler.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/metrics/stability_metrics_provider.h"
 #include "components/metrics/url_constants.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/entropy_provider.h"
+#include "net/base/network_change_notifier.h"

[Steven Holte, 2017/04/12 23:26:23]

I don't think net/ is allowed here, so this probably would need to be wrapped in
MetricsServiceClient or similar.

 
 namespace metrics {
 
 namespace {
 
 // This drops records if the number of events (user action and omnibox) exceeds
 // the kEventLimit.
 const base::Feature kUMAThrottleEvents{"UMAThrottleEvents",
                                        base::FEATURE_ENABLED_BY_DEFAULT};
 
@@ skipping 550 matching lines @@
   // TODO(stuartmorgan): Call Stop() on the scheduler when reporting and/or
   // recording are turned off instead of letting it fire and then aborting.
   if (idle_since_last_transmission_ ||
       !recording_active() ||
       (!reporting_active() && state_ >= SENDING_LOGS)) {
     rotation_scheduler_->Stop();
     rotation_scheduler_->RotationFinished();
     return;
   }
 
+  // Don't try to send existing logs or to collecting something new if there is
+  // no network connection. A cumulative log will be created at the next (or
+  // future) upload time when a network connection is available.
+  if (net::NetworkChangeNotifier::IsOffline())

[Steven Holte, 2017/04/12 23:11:37]

You should call (or schedule a call to) rotation_scheduler_->RotationFinished()
before exiting this function.

Collection of logs while offline is already somewhat suppressed.  The next if
condition checks has_unsent_logs, and if so, avoids generating a log.  So this
change will suppress generation of at most one log.

[Steven Holte, 2017/04/12 23:26:23]

Actually after rereading the code, this will also suppress generation of
"initial" logs if we happen to be in Offline mode at startup (state !=
SENDING_LOGS), so we'd be generating one log per session instead of 2, which
seems more significant, though that also means that we could generate a large
"initial" log.

[bcwhite, 2017/04/18 14:56:44]

Sounds like it's not worth it, then.  One (or even two) pending logs should be
fine; it's if it grows without bound that could be a problem for devices that
are off-line for hours or even days at a time but still viewing offline content
during that interval.

+    return;
+
   // If there are unsent logs, send the next one. If not, start the asynchronous
   // process of finalizing the current log for upload.
   if (state_ == SENDING_LOGS && has_unsent_logs()) {
     reporting_service_.Start();
     rotation_scheduler_->RotationFinished();
   } else {
     // There are no logs left to send, so start creating a new one.
     client_->CollectFinalMetricsForLog(
         base::Bind(&MetricsService::OnFinalLogInfoCollectionDone,
                    self_ptr_factory_.GetWeakPtr()));
@@ skipping 253 matching lines @@
   // Redundant setting to assure that we always reset this value at shutdown
   // (and that we don't use some alternate path, and not call LogCleanShutdown).
   clean_shutdown_status_ = CLEANLY_SHUTDOWN;
   client_->OnLogCleanShutdown();
   clean_exit_beacon_.WriteBeaconValue(true);
   SetExecutionPhase(ExecutionPhase::SHUTDOWN_COMPLETE, local_state_);
   StabilityMetricsProvider(local_state_).MarkSessionEndCompleted(end_completed);
 }
 
 }  // namespace metrics