Allow MetricsProviders to request an initial stability log.

components/metrics/metrics_service_unittest.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 "components/metrics/metrics_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 14 matching lines @@
 
 using metrics::MetricsLogManager;
 
 void StoreNoClientInfoBackup(const metrics::ClientInfo& /* client_info */) {
 }
 
 scoped_ptr<metrics::ClientInfo> ReturnNoBackup() {
   return scoped_ptr<metrics::ClientInfo>();
 }
 
+class TestMetricsProvider : public metrics::MetricsProvider {
+ public:
+  TestMetricsProvider(bool has_stability_metrics) :
+      has_stability_metrics_(has_stability_metrics),
+      provide_stability_metrics_called_(false) {
+  }
+
+  bool HasStabilityMetrics() OVERRIDE { return has_stability_metrics_; }
+  void ProvideStabilityMetrics(
+      metrics::SystemProfileProto* system_profile_proto) OVERRIDE {
+    provide_stability_metrics_called_ = true;
+  }
+
+  bool provide_stability_metrics_called() const {
+    return provide_stability_metrics_called_;
+  }
+
+ public:
+  bool has_stability_metrics_;
+  bool provide_stability_metrics_called_;
+};
+
 class TestMetricsService : public MetricsService {
  public:
   TestMetricsService(metrics::MetricsStateManager* state_manager,
                      metrics::MetricsServiceClient* client,
                      PrefService* local_state)
       : MetricsService(state_manager, client, local_state) {}
   virtual ~TestMetricsService() {}
 
   using MetricsService::log_manager;
 
@@ skipping 103 matching lines @@
 
 }  // namespace
 
 TEST_F(MetricsServiceTest, InitialStabilityLogAfterCleanShutDown) {
   EnableMetricsReporting();
   GetLocalState()->SetBoolean(metrics::prefs::kStabilityExitedCleanly, true);
 
   metrics::TestMetricsServiceClient client;
   TestMetricsService service(
       GetMetricsStateManager(), &client, GetLocalState());
+
+  TestMetricsProvider* test_provider = new TestMetricsProvider(false);
+  service.RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(test_provider));
+
   service.InitializeMetricsRecordingState();
   // No initial stability log should be generated.
   EXPECT_FALSE(service.log_manager()->has_unsent_logs());
   EXPECT_FALSE(service.log_manager()->has_staged_log());
+
+  // The test provider should not have been called upon to provide stability
+  // metrics.
+  EXPECT_FALSE(test_provider->provide_stability_metrics_called());
+}
+
+TEST_F(MetricsServiceTest, InitialStabilityLogAtProviderRequest) {
+  EnableMetricsReporting();
+
+  // Save an existing system profile to prefs, to correspond to what would be
+  // saved from a previous session.
+  metrics::TestMetricsServiceClient client;
+  TestMetricsLog log("client", 1, &client, GetLocalState());
+  log.RecordEnvironment(std::vector<metrics::MetricsProvider*>(),
+                        std::vector<variations::ActiveGroupId>(),
+                        0);
+
+  // Record stability build time and version from previous session, so that
+  // stability metrics (including exited cleanly flag) won't be cleared.
+  GetLocalState()->SetInt64(metrics::prefs::kStabilityStatsBuildTime,
+                        MetricsLog::GetBuildTime());
+  GetLocalState()->SetString(metrics::prefs::kStabilityStatsVersion,
+                         client.GetVersionString());
+
+  // Set the clean exit flag, as that will otherwise cause a stabilty
+  // log to be produced, irrespective provider requests.
+  GetLocalState()->SetBoolean(metrics::prefs::kStabilityExitedCleanly, true);
+
+  TestMetricsService service(
+      GetMetricsStateManager(), &client, GetLocalState());
+  // Add a metrics provider that requests a stability log.
+  TestMetricsProvider* test_provider = new TestMetricsProvider(true);
+  service.RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(test_provider));
+
+  service.InitializeMetricsRecordingState();
+
+  // The initial stability log should be generated and persisted in unsent logs.
+  MetricsLogManager* log_manager = service.log_manager();
+  EXPECT_TRUE(log_manager->has_unsent_logs());
+  EXPECT_FALSE(log_manager->has_staged_log());
+
+  // The test provider should have been called upon to provide stabilit
+  // metrics.
+  EXPECT_TRUE(test_provider->provide_stability_metrics_called());
+
+  // Stage the log and retrieve it.
+  log_manager->StageNextLogForUpload();
+  EXPECT_TRUE(log_manager->has_staged_log());
+
+  std::string uncompressed_log;
+  EXPECT_TRUE(metrics::GzipUncompress(log_manager->staged_log(),
+                                      &uncompressed_log));
+
+  metrics::ChromeUserMetricsExtension uma_log;
+  EXPECT_TRUE(uma_log.ParseFromString(uncompressed_log));
+
+  EXPECT_TRUE(uma_log.has_client_id());
+  EXPECT_TRUE(uma_log.has_session_id());
+  EXPECT_TRUE(uma_log.has_system_profile());
+  EXPECT_EQ(0, uma_log.user_action_event_size());
+  EXPECT_EQ(0, uma_log.omnibox_event_size());
+  EXPECT_EQ(0, uma_log.histogram_event_size());
+  EXPECT_EQ(0, uma_log.profiler_event_size());
+  EXPECT_EQ(0, uma_log.perf_data_size());
+
+  // As there wasn't an unclean shutdown, this log has zero crash count.
+  EXPECT_EQ(0, uma_log.system_profile().stability().crash_count());
 }
 
 TEST_F(MetricsServiceTest, InitialStabilityLogAfterCrash) {
   EnableMetricsReporting();
   GetLocalState()->ClearPref(metrics::prefs::kStabilityExitedCleanly);
 
   // Set up prefs to simulate restarting after a crash.
 
   // Save an existing system profile to prefs, to correspond to what would be
   // saved from a previous session.
@@ skipping 135 matching lines @@
 
   service.RemoveObserver(&observer1);
 
   service.OpenNewLog();
   EXPECT_EQ(2, observer1.observed());
   EXPECT_EQ(2, observer2.observed());
   service.log_manager_.FinishCurrentLog();
 
   service.RemoveObserver(&observer2);
 }