Make MetricsService upload logs through an interface.

chrome/browser/metrics/metrics_service.cc

 // Copyright (c) 2012 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 167 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked_objects.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
-#include "chrome/browser/metrics/compression_utils.h"
 #include "chrome/browser/metrics/gpu_metrics_provider.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_state_manager.h"
 #include "chrome/browser/metrics/network_metrics_provider.h"
 #include "chrome/browser/metrics/omnibox_metrics_provider.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/variations/variations_util.h"
 #include "components/metrics/metrics_log_base.h"
 #include "components/metrics/metrics_log_manager.h"
+#include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_scheduler.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/variations/entropy_provider.h"
-#include "net/base/load_flags.h"
-#include "net/url_request/url_fetcher.h"
 
 #if defined(ENABLE_PLUGINS)
 // TODO(asvitkine): Move this out of MetricsService.
 #include "chrome/browser/metrics/plugin_metrics_provider.h"
 #endif
 
 #if defined(OS_WIN)
 #include "chrome/browser/metrics/google_update_metrics_provider_win.h"
 #endif
 
@@ skipping 48 matching lines @@
 enum ResponseStatus {
   UNKNOWN_FAILURE,
   SUCCESS,
   BAD_REQUEST,  // Invalid syntax or log too large.
   NO_RESPONSE,
   NUM_RESPONSE_STATUSES
 };
 
 ResponseStatus ResponseCodeToStatus(int response_code) {
   switch (response_code) {
+    case -1:
+      return NO_RESPONSE;
     case 200:
       return SUCCESS;
     case 400:
       return BAD_REQUEST;
-    case net::URLFetcher::RESPONSE_CODE_INVALID:
-      return NO_RESPONSE;
     default:
       return UNKNOWN_FAILURE;
   }
 }
 
 void MarkAppCleanShutdownAndCommit(PrefService* local_state) {
   local_state->SetBoolean(prefs::kStabilityExitedCleanly, true);
   local_state->SetInteger(prefs::kStabilityExecutionPhase,
                           MetricsService::SHUTDOWN_COMPLETE);
   // Start writing right away (write happens on a different thread).
@@ skipping 75 matching lines @@
     : log_manager_(local_state, kUploadLogAvoidRetransmitSize),
       histogram_snapshot_manager_(this),
       state_manager_(state_manager),
       client_(client),
       local_state_(local_state),
       recording_active_(false),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       has_initial_stability_log_(false),
+      log_upload_in_progress_(false),
       idle_since_last_transmission_(false),
       session_id_(-1),
       self_ptr_factory_(this),
-      state_saver_factory_(this),
-      waiting_for_asynchronous_reporting_step_(false) {
+      state_saver_factory_(this) {
   DCHECK(IsSingleThreaded());
   DCHECK(state_manager_);
   DCHECK(client_);
   DCHECK(local_state_);
 
 #if defined(OS_ANDROID)
   // TODO(asvitkine): Move this out of MetricsService.
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new AndroidMetricsProvider(
           local_state_)));
@@ skipping 489 matching lines @@
   log_manager_.FinishCurrentLog();
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
   if (state_ < SENDING_INITIAL_STABILITY_LOG)
     return;  // We didn't and still don't have time to get plugin list etc.
 
   if (log_manager_.has_staged_log()) {
     // We may race here, and send second copy of the log later.
     metrics::PersistedLogs::StoreType store_type;
-    if (current_fetch_.get())
+    if (log_upload_in_progress_)
       store_type = metrics::PersistedLogs::PROVISIONAL_STORE;
     else
       store_type = metrics::PersistedLogs::NORMAL_STORE;
     log_manager_.StoreStagedLogAsUnsent(store_type);
   }
   DCHECK(!log_manager_.has_staged_log());
   CloseCurrentLog();
   log_manager_.PersistUnsentLogs();
 
   // If there was a staged and/or current log, then there is now at least one
@@ skipping 54 matching lines @@
     log_manager_.StageNextLogForUpload();
     SendStagedLog();
   } else {
     client_->CollectFinalMetrics(
         base::Bind(&MetricsService::OnFinalLogInfoCollectionDone,
                    self_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void MetricsService::OnFinalLogInfoCollectionDone() {
-  // If somehow there is a fetch in progress, we return and hope things work
-  // out. The scheduler isn't informed since if this happens, the scheduler
+  // If somehow there is a log upload in progress, we return and hope things
+  // work out. The scheduler isn't informed since if this happens, the scheduler
   // will get a response from the upload.
-  DCHECK(!current_fetch_.get());
-  if (current_fetch_.get())
+  DCHECK(!log_upload_in_progress_);
+  if (log_upload_in_progress_)
     return;
 
   // Abort if metrics were turned off during the final info gathering.
   if (!recording_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
   StageNewLog();
@@ skipping 126 matching lines @@
 
   log_manager_.FinishCurrentLog();
   log_manager_.ResumePausedLog();
 
   DCHECK(!log_manager_.has_staged_log());
   log_manager_.StageNextLogForUpload();
 }
 
 void MetricsService::SendStagedLog() {
   DCHECK(log_manager_.has_staged_log());
+  if (!log_manager_.has_staged_log())
+    return;
 
-  PrepareFetchWithStagedLog();
+  DCHECK(!log_upload_in_progress_);
+  log_upload_in_progress_ = true;
 
-  bool upload_created = (current_fetch_.get() != NULL);
-  UMA_HISTOGRAM_BOOLEAN("UMA.UploadCreation", upload_created);
-  if (!upload_created) {
-    // Compression failed, and log discarded :-/.
+  if (!log_uploader_) {
+    log_uploader_ = client_->CreateUploader(
+        kServerUrl, kMimeType,
+        base::Bind(&MetricsService::OnLogUploadComplete,
+                   self_ptr_factory_.GetWeakPtr()));
+  }
+
+  const std::string hash =
+      base::HexEncode(log_manager_.staged_log_hash().data(),
+                      log_manager_.staged_log_hash().size());
+  bool success = log_uploader_->UploadLog(log_manager_.staged_log(), hash);
+  UMA_HISTOGRAM_BOOLEAN("UMA.UploadCreation", success);
+  if (!success) {
     // Skip this upload and hope things work out next time.
     log_manager_.DiscardStagedLog();
     scheduler_->UploadCancelled();
+    log_upload_in_progress_ = false;
     return;
   }
 
-  DCHECK(!waiting_for_asynchronous_reporting_step_);
-  waiting_for_asynchronous_reporting_step_ = true;
-
-  current_fetch_->Start();
-
   HandleIdleSinceLastTransmission(true);
 }
 
-void MetricsService::PrepareFetchWithStagedLog() {
-  DCHECK(log_manager_.has_staged_log());
 
-  // Prepare the protobuf version.
-  DCHECK(!current_fetch_.get());
-  if (log_manager_.has_staged_log()) {
-    current_fetch_.reset(net::URLFetcher::Create(
-        GURL(kServerUrl), net::URLFetcher::POST, this));
-    current_fetch_->SetRequestContext(
-        g_browser_process->system_request_context());
-
-    std::string log_text = log_manager_.staged_log();
-    std::string compressed_log_text;
-    bool compression_successful = chrome::GzipCompress(log_text,
-                                                       &compressed_log_text);
-    DCHECK(compression_successful);
-    if (compression_successful) {
-      current_fetch_->SetUploadData(kMimeType, compressed_log_text);
-      // Tell the server that we're uploading gzipped protobufs.
-      current_fetch_->SetExtraRequestHeaders("content-encoding: gzip");
-      const std::string hash =
-          base::HexEncode(log_manager_.staged_log_hash().data(),
-                          log_manager_.staged_log_hash().size());
-      DCHECK(!hash.empty());
-      current_fetch_->AddExtraRequestHeader("X-Chrome-UMA-Log-SHA1: " + hash);
-      UMA_HISTOGRAM_PERCENTAGE(
-          "UMA.ProtoCompressionRatio",
-          100 * compressed_log_text.size() / log_text.size());
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "UMA.ProtoGzippedKBSaved",
-          (log_text.size() - compressed_log_text.size()) / 1024,
-          1, 2000, 50);
-    }
-
-    // We already drop cookies server-side, but we might as well strip them out
-    // client-side as well.
-    current_fetch_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
-                                 net::LOAD_DO_NOT_SEND_COOKIES);
-  }
-}
-
-void MetricsService::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(waiting_for_asynchronous_reporting_step_);
-
-  // We're not allowed to re-use the existing |URLFetcher|s, so free them here.
-  // Note however that |source| is aliased to the fetcher, so we should be
-  // careful not to delete it too early.
-  DCHECK_EQ(current_fetch_.get(), source);
-  scoped_ptr<net::URLFetcher> s(current_fetch_.Pass());
-
-  int response_code = source->GetResponseCode();
+void MetricsService::OnLogUploadComplete(int response_code) {
+  DCHECK(log_upload_in_progress_);
+  log_upload_in_progress_ = false;
 
   // Log a histogram to track response success vs. failure rates.
   UMA_HISTOGRAM_ENUMERATION("UMA.UploadResponseStatus.Protobuf",
                             ResponseCodeToStatus(response_code),
                             NUM_RESPONSE_STATUSES);
 
   // If the upload was provisionally stored, drop it now that the upload is
   // known to have gone through.
   log_manager_.DiscardLastProvisionalStore();
 
   bool upload_succeeded = response_code == 200;
 
   // Provide boolean for error recovery (allow us to ignore response_code).
   bool discard_log = false;
   const size_t log_size = log_manager_.staged_log().length();
   if (!upload_succeeded && log_size > kUploadLogAvoidRetransmitSize) {
     UMA_HISTOGRAM_COUNTS("UMA.Large Rejected Log was Discarded",
                          static_cast<int>(log_size));
     discard_log = true;
   } else if (response_code == 400) {
     // Bad syntax.  Retransmission won't work.
     discard_log = true;
   }
 
   if (upload_succeeded || discard_log)
     log_manager_.DiscardStagedLog();
 
-  waiting_for_asynchronous_reporting_step_ = false;
-
   if (!log_manager_.has_staged_log()) {
     switch (state_) {
       case SENDING_INITIAL_STABILITY_LOG:
         // Store the updated list to disk now that the removed log is uploaded.
         log_manager_.PersistUnsentLogs();
         PrepareInitialMetricsLog();
         SendStagedLog();
         state_ = SENDING_INITIAL_METRICS_LOG;
         break;
 
@@ skipping 149 matching lines @@
   RecordCurrentState(local_state_);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
 #if defined(ENABLE_PLUGINS)
   plugin_metrics_provider_->RecordPluginChanges();
 #endif
 }