Move logic for uploading logs into a ReportingService object.

components/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef COMPONENTS_METRICS_METRICS_SERVICE_H_
 #define COMPONENTS_METRICS_METRICS_SERVICE_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_flattener.h"
 #include "base/metrics/histogram_snapshot_manager.h"
 #include "base/metrics/user_metrics.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/metrics/clean_exit_beacon.h"
-#include "components/metrics/data_use_tracker.h"
 #include "components/metrics/execution_phase.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_log_store.h"
 #include "components/metrics/metrics_provider.h"
+#include "components/metrics/metrics_reporting_service.h"
 #include "components/metrics/net/network_metrics_provider.h"
 #include "components/variations/synthetic_trials.h"
 
 class PrefService;
 class PrefRegistrySimple;
 
 namespace base {
 class HistogramSamples;
 class PrefService;
 }
 
 namespace variations {
 struct ActiveGroupId;
 }
 
 namespace metrics {
 
-class MetricsLogUploader;
 class MetricsRotationScheduler;
-class MetricsUploadScheduler;
 class MetricsServiceAccessor;
 class MetricsServiceClient;
 class MetricsStateManager;
 
 // See metrics_service.cc for a detailed description.
 class MetricsService : public base::HistogramFlattener {
  public:
   // Creates the MetricsService with the given |state_manager|, |client|, and
   // |local_state|.  Does not take ownership of the paramaters; instead stores
   // a weak pointer to each. Caller should ensure that the parameters are valid
@@ skipping 37 matching lines @@
   // Returns the install date of the application, in seconds since the epoch.
   int64_t GetInstallDate();
 
   // Returns the date at which the current metrics client ID was created as
   // an int64_t containing seconds since the epoch.
   int64_t GetMetricsReportingEnabledDate();
 
   // Returns true if the last session exited cleanly.
   bool WasLastShutdownClean() const;
 
-  // At startup, prefs needs to be called with a list of all the pref names and
-  // types we'll be using.
+  // Registers local state prefs used by this class.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // HistogramFlattener:
   void RecordDelta(const base::HistogramBase& histogram,
                    const base::HistogramSamples& snapshot) override;
   void InconsistencyDetected(
       base::HistogramBase::Inconsistency problem) override;
   void UniqueInconsistencyDetected(
       base::HistogramBase::Inconsistency problem) override;
   void InconsistencyDetectedInLoggedCount(int amount) override;
@@ skipping 27 matching lines @@
   // Saves in the preferences if the crash report registration was successful.
   // This count is eventually send via UMA logs.
   void RecordBreakpadRegistration(bool success);
 
   // Saves in the preferences if the browser is running under a debugger.
   // This count is eventually send via UMA logs.
   void RecordBreakpadHasDebugger(bool has_debugger);
 
   bool recording_active() const;
   bool reporting_active() const;
+  bool has_unsent_logs() const;
 
   // Redundant test to ensure that we are notified of a clean exit.
   // This value should be true when process has completed shutdown.
   static bool UmaMetricsProperlyShutdown();
 
   // Public accessor that returns the list of synthetic field trials. It must
   // only be used for testing.
   void GetCurrentSyntheticFieldTrialsForTesting(
       std::vector<variations::ActiveGroupId>* synthetic_trials);
 
@@ skipping 21 matching lines @@
   void PushExternalLog(const std::string& log);
 
   // Updates data usage tracking prefs with the specified values.
   void UpdateMetricsUsagePrefs(const std::string& service_name,
                                int message_size,
                                bool is_cellular);
 
  protected:
   // Exposed for testing.
   MetricsLogManager* log_manager() { return &log_manager_; }
-  MetricsLogStore* log_store() { return &log_store_; }
+  MetricsLogStore* log_store() {
+    return reporting_service_.metrics_log_store();
+  }
 
  private:
   friend class MetricsServiceAccessor;
 
   // The MetricsService has a lifecycle that is stored as a state.
   // See metrics_service.cc for description of this lifecycle.
   enum State {
     INITIALIZED,          // Constructor was called.
     INIT_TASK_SCHEDULED,  // Waiting for deferred init tasks to finish.
     INIT_TASK_DONE,       // Waiting for timer to send initial log.
@@ skipping 86 matching lines @@
   // that metrics should be reported. If not, this is a no-op.
   void StartSchedulerIfNecessary();
 
   // Starts the process of uploading metrics data.
   void StartScheduledUpload();
 
   // Called by the client via a callback when final log info collection is
   // complete.
   void OnFinalLogInfoCollectionDone();
 
-  // If recording is enabled, begins uploading the next completed log from
-  // the log manager, staging it if necessary.
-  void SendNextLog();
-
   // Returns true if any of the registered metrics providers have critical
   // stability metrics to report in an initial stability log.
   bool ProvidersHaveInitialStabilityMetrics();
 
   // Prepares the initial stability log, which is only logged when the previous
   // run of Chrome crashed.  This log contains any stability metrics left over
   // from that previous run, and only these stability metrics.  It uses the
   // system profile from the previous session.  |prefs_previous_version| is used
   // to validate the version number recovered from the system profile.  Returns
   // true if a log was created.
   bool PrepareInitialStabilityLog(const std::string& prefs_previous_version);
 
   // Prepares the initial metrics log, which includes startup histograms and
   // profiler data, as well as incremental stability-related metrics.
   void PrepareInitialMetricsLog();
 
-  // Uploads the currently staged log (which must be non-null).
-  void SendStagedLog();
-
-  // Called after transmission completes (either successfully or with failure).
-  void OnLogUploadComplete(int response_code);
-
   // Reads, increments and then sets the specified long preference that is
   // stored as a string.
   void IncrementLongPrefsValue(const char* path);
 
   // Records that the browser was shut down cleanly.
   void LogCleanShutdown(bool end_completed);
 
   // Notifies observers on a synthetic trial list change.
   void NotifySyntheticTrialObservers();
 
   // Returns a list of synthetic field trials that are older than |time|.
   void GetSyntheticFieldTrialsOlderThan(
       base::TimeTicks time,
       std::vector<variations::ActiveGroupId>* synthetic_trials);
 
   // Creates a new MetricsLog instance with the given |log_type|.
   std::unique_ptr<MetricsLog> CreateLog(MetricsLog::LogType log_type);
 
   // Records the current environment (system profile) in |log|.
   void RecordCurrentEnvironment(MetricsLog* log);
 
   // Record complete list of histograms into the current log.
   // Called when we close a log.
   void RecordCurrentHistograms();
 
   // Record complete list of stability histograms into the current log,
   // i.e., histograms with the |kUmaStabilityHistogramFlag| flag set.
   void RecordCurrentStabilityHistograms();
 
+  // Sub-service for uploading logs.
+  MetricsReportingService reporting_service_;
+
   // Manager for the various in-flight logs.
   MetricsLogManager log_manager_;
 
-  // Store of logs ready to be uploaded.
-  MetricsLogStore log_store_;
-
   // |histogram_snapshot_manager_| prepares histogram deltas for transmission.
   base::HistogramSnapshotManager histogram_snapshot_manager_;
 
   // Used to manage various metrics reporting state prefs, such as client id,
   // low entropy source and whether metrics reporting is enabled. Weak pointer.
   MetricsStateManager* const state_manager_;
 
   // Used to interact with the embedder. Weak pointer; must outlive |this|
   // instance.
   MetricsServiceClient* const client_;
 
   // Registered metrics providers.
   std::vector<std::unique_ptr<MetricsProvider>> metrics_providers_;
 
   PrefService* local_state_;
 
   CleanExitBeacon clean_exit_beacon_;
 
   base::ActionCallback action_callback_;
 
   // Indicate whether recording and reporting are currently happening.
   // These should not be set directly, but by calling SetRecording and
   // SetReporting.
   RecordingState recording_state_;
-  bool reporting_active_;
 
   // Indicate whether test mode is enabled, where the initial log should never
   // be cut, and logs are neither persisted nor uploaded.
   bool test_mode_active_;
 
   // The progression of states made by the browser are recorded in the following
   // state.
   State state_;
 
   // The initial metrics log, used to record startup metrics (histograms and
   // profiler data). Note that if a crash occurred in the previous session, an
   // initial stability log may be sent before this.
   std::unique_ptr<MetricsLog> initial_metrics_log_;
 
-  // Instance of the helper class for uploading logs.
-  std::unique_ptr<MetricsLogUploader> log_uploader_;
-
-  // Whether there is a current log upload in progress.
-  bool log_upload_in_progress_;
-
   // Whether the MetricsService object has received any notifications since
   // the last time a transmission was sent.
   bool idle_since_last_transmission_;
 
   // A number that identifies the how many times the app has been launched.
   int session_id_;
 
   // The scheduler for determining when log rotations should happen.
   std::unique_ptr<MetricsRotationScheduler> rotation_scheduler_;
-  // The scheduler for determining when uploads should happen.
-  std::unique_ptr<MetricsUploadScheduler> upload_scheduler_;
 
   // Stores the time of the first call to |GetUptimes()|.
   base::TimeTicks first_updated_time_;
 
   // Stores the time of the last call to |GetUptimes()|.
   base::TimeTicks last_updated_time_;
 
   // Field trial groups that map to Chrome configuration states.
   SyntheticTrialGroups synthetic_trial_groups_;
 
   // List of observers of |synthetic_trial_groups_| changes.
   base::ObserverList<variations::SyntheticTrialObserver>
       synthetic_trial_observer_list_;
 
   // Redundant marker to check that we completed our shutdown, and set the
   // exited-cleanly bit in the prefs.
   static ShutdownCleanliness clean_shutdown_status_;
 
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, IsPluginProcess);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest,
                            PermutedEntropyCacheClearedWhenLowEntropyReset);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, RegisterSyntheticTrial);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest,
                            RegisterSyntheticMultiGroupFieldTrial);
 
-  // Pointer used for obtaining data use pref updater callback on above layers.
-  std::unique_ptr<DataUseTracker> data_use_tracker_;
-
   base::ThreadChecker thread_checker_;
 
   // Weak pointers factory used to post task on different threads. All weak
   // pointers managed by this factory have the same lifetime as MetricsService.
   base::WeakPtrFactory<MetricsService> self_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_METRICS_SERVICE_H_