[UMA] Begin ripping out XML uploading code.

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 the central controller for the acquisition of log data, and the automatic
+// A MetricsService instance is typically created at application startup.  It is
+// the central controller for the acquisition of log data, and the automatic
 // transmission of that log data to an external server.  Its major job is to
 // manage logs, grouping them for transmission, and transmitting them.  As part
 // of its grouping, MS finalizes logs by including some just-in-time gathered
 // memory statistics, snapshotting the current stats of numerous histograms,
-// closing the logs, translating to XML text, and compressing the results for
-// transmission.  Transmission includes submitting a compressed log as data in a
-// URL-post, and retransmitting (or retaining at process termination) if the
-// attempted transmission failed.  Retention across process terminations is done
-// using the the PrefServices facilities. The retained logs (the ones that never
-// got transmitted) are compressed and base64-encoded before being persisted.
+// closing the logs, translating to protocol buffer format, and compressing the
+// results for transmission.  Transmission includes submitting a compressed log
+// as data in a URL-post, and retransmitting (or retaining at process
+// termination) if the attempted transmission failed.  Retention across process
+// terminations is done using the the PrefServices facilities. The retained logs
+// (the ones that never got transmitted) are compressed and base64-encoded
+// before being persisted.
 //
 // Logs fall into one of two categories: "initial logs," and "ongoing logs."
 // There is at most one initial log sent for each complete run of the chromium
 // product (from startup, to browser shutdown).  An initial log is generally
 // transmitted some short time (1 minute?) after startup, and includes stats
 // such as recent crash info, the number and types of plugins, etc.  The
 // external server's response to the initial log conceptually tells this MS if
 // it should continue transmitting logs (during this session). The server
 // response can actually be much more detailed, and always includes (at a
 // minimum) how often additional ongoing logs should be sent.
@@ skipping 775 matching lines @@
 //------------------------------------------------------------------------------
 // private methods
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
 // Initialization methods
 
 void MetricsService::InitializeMetricsState() {
 #if defined(OS_POSIX)
-  server_url_xml_ = ASCIIToUTF16(kServerUrlXml);
-  server_url_proto_ = ASCIIToUTF16(kServerUrlProto);
   network_stats_server_ = chrome_common_net::kEchoTestServerLocation;
   http_pipelining_test_server_ = chrome_common_net::kPipelineTestServerBaseUrl;
 #else
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  server_url_xml_ = dist->GetStatsServerURL();
-  server_url_proto_ = ASCIIToUTF16(kServerUrlProto);
   network_stats_server_ = dist->GetNetworkStatsServer();
   http_pipelining_test_server_ = dist->GetHttpPipeliningTestServer();
 #endif
 
   PrefService* pref = g_browser_process->local_state();
   DCHECK(pref);
 
   if ((pref->GetInt64(prefs::kStabilityStatsBuildTime)
        != MetricsLog::GetBuildTime()) ||
       (pref->GetString(prefs::kStabilityStatsVersion)
@@ skipping 313 matching lines @@
   log_manager_.FinishCurrentLog();
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
   if (state_ < INITIAL_LOG_READY)
     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.
     MetricsLogManager::StoreType store_type;
-    if (current_fetch_xml_.get() || current_fetch_proto_.get())
+    if (current_fetch_.get())
       store_type = MetricsLogManager::PROVISIONAL_STORE;
     else
       store_type = MetricsLogManager::NORMAL_STORE;
     log_manager_.StoreStagedLogAsUnsent(store_type);
   }
   DCHECK(!log_manager_.has_staged_log());
   CloseCurrentLog();
   StoreUnsentLogs();
 
   // If there was a staged and/or current log, then there is now at least one
@@ skipping 108 matching lines @@
   DCHECK(waiting_for_asynchronous_reporting_step_);
 
   waiting_for_asynchronous_reporting_step_ = false;
   OnFinalLogInfoCollectionDone();
 }
 
 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
   // will get a response from the upload.
-  DCHECK(!current_fetch_xml_.get());
-  DCHECK(!current_fetch_proto_.get());
-  if (current_fetch_xml_.get() || current_fetch_proto_.get())
+  DCHECK(!current_fetch_.get());
+  if (current_fetch_.get())
     return;
 
   // Abort if metrics were turned off during the final info gathering.
   if (!recording_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
   StageNewLog();
@@ skipping 74 matching lines @@
     return;  // We never Recalled the prior unsent logs.
 
   log_manager_.PersistUnsentLogs();
 }
 
 void MetricsService::SendStagedLog() {
   DCHECK(log_manager_.has_staged_log());
 
   PrepareFetchWithStagedLog();
 
-  bool upload_created = current_fetch_xml_.get() || current_fetch_proto_.get();
+  bool upload_created = (current_fetch_.get() != NULL);
   UMA_HISTOGRAM_BOOLEAN("UMA.UploadCreation", upload_created);
   if (!upload_created) {
     // Compression failed, and log discarded :-/.
     // Skip this upload and hope things work out next time.
     log_manager_.DiscardStagedLog();
     scheduler_->UploadCancelled();
     return;
   }
 
   DCHECK(!waiting_for_asynchronous_reporting_step_);
   waiting_for_asynchronous_reporting_step_ = true;
 
-  if (current_fetch_xml_.get())
-    current_fetch_xml_->Start();
-  if (current_fetch_proto_.get())
-    current_fetch_proto_->Start();
+  current_fetch_->Start();
 
   HandleIdleSinceLastTransmission(true);
 }
 
 void MetricsService::PrepareFetchWithStagedLog() {
   DCHECK(log_manager_.has_staged_log());
 
-  // Prepare the XML version.
-  DCHECK(!current_fetch_xml_.get());
-  if (log_manager_.has_staged_log_xml()) {
-    current_fetch_xml_.reset(net::URLFetcher::Create(
-        GURL(server_url_xml_), net::URLFetcher::POST, this));
-    current_fetch_xml_->SetRequestContext(
+  // Prepare the protobuf version.
+  DCHECK(!current_fetch_.get());
+  if (log_manager_.has_staged_log_proto()) {
+    current_fetch_.reset(net::URLFetcher::Create(
+        GURL(kServerUrlProto), net::URLFetcher::POST, this));
+    current_fetch_->SetRequestContext(
         g_browser_process->system_request_context());
-    current_fetch_xml_->SetUploadData(kMimeTypeXml,
-                                      log_manager_.staged_log_text().xml);
+    current_fetch_->SetUploadData(kMimeTypeProto,
+                                  log_manager_.staged_log_text().proto);
     // We already drop cookies server-side, but we might as well strip them out
     // client-side as well.
-    current_fetch_xml_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
-                                     net::LOAD_DO_NOT_SEND_COOKIES);
-  }
-
-  // Prepare the protobuf version.
-  DCHECK(!current_fetch_proto_.get());
-  if (log_manager_.has_staged_log_proto()) {
-    current_fetch_proto_.reset(net::URLFetcher::Create(
-        GURL(server_url_proto_), net::URLFetcher::POST, this));
-    current_fetch_proto_->SetRequestContext(
-        g_browser_process->system_request_context());
-    current_fetch_proto_->SetUploadData(kMimeTypeProto,
-                                        log_manager_.staged_log_text().proto);
-    // We already drop cookies server-side, but we might as well strip them out
-    // client-side as well.
-    current_fetch_proto_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
-                                       net::LOAD_DO_NOT_SEND_COOKIES);
+    current_fetch_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
+                                 net::LOAD_DO_NOT_SEND_COOKIES);
   }
 }
 
-// We need to wait for two responses: the response to the XML upload, and the
-// response to the protobuf upload.  In the case that exactly one of the uploads
-// fails and needs to be retried, we "zap" the other pipeline's staged log to
-// avoid incorrectly re-uploading it as well.
 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 one of these, so we should be
+  // Note however that |source| is aliased to the fetcher, so we should be
   // careful not to delete it too early.
-  scoped_ptr<net::URLFetcher> s;
-  bool is_xml;
-  if (source == current_fetch_xml_.get()) {
-    s.reset(current_fetch_xml_.release());
-    is_xml = true;
-  } else if (source == current_fetch_proto_.get()) {
-    s.reset(current_fetch_proto_.release());
-    is_xml = false;
-  } else {
-    NOTREACHED();
-    return;
-  }
+  DCHECK_EQ(current_fetch_.get(), source);
+  scoped_ptr<net::URLFetcher> s(current_fetch_.Pass());
 
   int response_code = source->GetResponseCode();
 
   // Log a histogram to track response success vs. failure rates.
-  if (is_xml) {
-    UMA_HISTOGRAM_ENUMERATION("UMA.UploadResponseStatus.XML",
-                              ResponseCodeToStatus(response_code),
-                              NUM_RESPONSE_STATUSES);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION("UMA.UploadResponseStatus.Protobuf",
-                              ResponseCodeToStatus(response_code),
-                              NUM_RESPONSE_STATUSES);
-  }
+  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 = is_xml ?
-      log_manager_.staged_log_text().xml.length() :
-      log_manager_.staged_log_text().proto.length();
+  const size_t log_size = log_manager_.staged_log_text().proto.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) {
-    if (is_xml)
-      log_manager_.DiscardStagedLogXml();
-    else
-      log_manager_.DiscardStagedLogProto();
-  }
-
-  // If we're still waiting for one of the responses, keep waiting...
-  if (current_fetch_xml_.get() || current_fetch_proto_.get())
-    return;
+  if (upload_succeeded || discard_log)
+    log_manager_.DiscardStagedLogProto();
 
   waiting_for_asynchronous_reporting_step_ = false;
 
   if (!log_manager_.has_staged_log()) {
     switch (state_) {
       case INITIAL_LOG_READY:
         state_ = log_manager_.has_unsent_logs() ? SENDING_OLD_LOGS
                                                 : SENDING_CURRENT_LOGS;
         break;
 
@@ skipping 12 matching lines @@
         break;
     }
 
     if (log_manager_.has_unsent_logs())
       DCHECK_LT(state_, SENDING_CURRENT_LOGS);
   }
 
   // Error 400 indicates a problem with the log, not with the server, so
   // don't consider that a sign that the server is in trouble.
   bool server_is_healthy = upload_succeeded || response_code == 400;
-
-  // Note that we are essentially randomly choosing to report either the XML or
-  // the protobuf server's health status, but this is ok: In the case that the
-  // two statuses are not the same, one of the uploads succeeded but the other
-  // did not. In this case, we'll re-try only the upload that failed. This first
-  // re-try might ignore the server's unhealthiness; but the response to the
-  // re-tried upload will correctly propagate the server's health status for any
-  // subsequent re-tries. Hence, we'll at most delay slowing the upload rate by
-  // one re-try, which is fine.
   scheduler_->UploadFinished(server_is_healthy, log_manager_.has_unsent_logs());
 
   // Collect network stats if UMA upload succeeded.
   IOThread* io_thread = g_browser_process->io_thread();
   if (server_is_healthy && io_thread) {
     chrome_browser_net::CollectNetworkStats(network_stats_server_, io_thread);
     chrome_browser_net::CollectPipeliningCapabilityStatsOnUIThread(
         http_pipelining_test_server_, io_thread);
   }
 }
@@ skipping 314 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }