Add server_url and mime_type params to CreateUploader.

This will allow for reuse by Rappor/UKM.

BUG=678682

Review-Url: https://codereview.chromium.org/2614533002
Cr-Commit-Position: refs/heads/master@{#441809}

android_webview/browser/aw_metrics_service_client.cc

@@ -201,11 +201,12 @@ void AwMetricsServiceClient::CollectFinalMetricsForLog(
 
 std::unique_ptr<metrics::MetricsLogUploader>
 AwMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
     const base::Callback<void(int)>& on_upload_complete) {
   return std::unique_ptr<::metrics::MetricsLogUploader>(
       new metrics::NetMetricsLogUploader(
-          request_context_, metrics::kDefaultMetricsServerUrl,
-          metrics::kDefaultMetricsMimeType, on_upload_complete));
+          request_context_, server_url, mime_type, on_upload_complete));
 }
 
 base::TimeDelta AwMetricsServiceClient::GetStandardUploadInterval() {

android_webview/browser/aw_metrics_service_client.h

@@ -66,6 +66,8 @@ class AwMetricsServiceClient : public metrics::MetricsServiceClient,
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
   std::unique_ptr<metrics::MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
 

blimp/engine/app/blimp_metrics_service_client.cc

@@ -139,11 +139,13 @@ void BlimpMetricsServiceClient::CollectFinalMetricsForLog(
 
 std::unique_ptr<metrics::MetricsLogUploader>
 BlimpMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
     const base::Callback<void(int)>& on_upload_complete) {
   return base::WrapUnique<metrics::MetricsLogUploader>(
       new metrics::NetMetricsLogUploader(
-          request_context_getter_.get(), metrics::kDefaultMetricsServerUrl,
-          metrics::kDefaultMetricsMimeType, on_upload_complete));
+          request_context_getter_.get(), server_url,
+          mime_type, on_upload_complete));
 }
 
 base::TimeDelta BlimpMetricsServiceClient::GetStandardUploadInterval() {

blimp/engine/app/blimp_metrics_service_client.h

@@ -57,6 +57,8 @@ class BlimpMetricsServiceClient : public metrics::MetricsServiceClient,
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
   std::unique_ptr<metrics::MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
   metrics::EnableMetricsDefault GetMetricsReportingDefaultState() override;

chrome/browser/metrics/chrome_metrics_service_client.cc

@@ -506,12 +506,13 @@ void ChromeMetricsServiceClient::CollectFinalMetricsForLog(
 
 std::unique_ptr<metrics::MetricsLogUploader>
 ChromeMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
     const base::Callback<void(int)>& on_upload_complete) {
   return std::unique_ptr<metrics::MetricsLogUploader>(
       new metrics::NetMetricsLogUploader(
           g_browser_process->system_request_context(),
-          metrics::kDefaultMetricsServerUrl, metrics::kDefaultMetricsMimeType,
-          on_upload_complete));
+          server_url, mime_type, on_upload_complete));
 }
 
 base::TimeDelta ChromeMetricsServiceClient::GetStandardUploadInterval() {

chrome/browser/metrics/chrome_metrics_service_client.h

@@ -74,6 +74,8 @@ class ChromeMetricsServiceClient
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
   std::unique_ptr<metrics::MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
   base::string16 GetRegistryBackupKey() override;

chromecast/browser/metrics/cast_metrics_service_client.cc

@@ -232,9 +232,7 @@ void CastMetricsServiceClient::CollectFinalMetricsForLog(
   done_callback.Run();
 }
 
-std::unique_ptr<::metrics::MetricsLogUploader>
-CastMetricsServiceClient::CreateUploader(
-    const base::Callback<void(int)>& on_upload_complete) {
+std::string CastMetricsServiceClient::GetMetricsServerUrl() {
   std::string uma_server_url(::metrics::kDefaultMetricsServerUrl);
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kOverrideMetricsUploadUrl)) {
@@ -242,10 +240,17 @@ CastMetricsServiceClient::CreateUploader(
         command_line->GetSwitchValueASCII(switches::kOverrideMetricsUploadUrl));
   }
   DCHECK(!uma_server_url.empty());
+  return uma_server_url;
+}
+
+std::unique_ptr<::metrics::MetricsLogUploader>
+CastMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
+    const base::Callback<void(int)>& on_upload_complete) {
   return std::unique_ptr<::metrics::MetricsLogUploader>(
-      new ::metrics::NetMetricsLogUploader(request_context_, uma_server_url,
-                                           ::metrics::kDefaultMetricsMimeType,
-                                           on_upload_complete));
+      new ::metrics::NetMetricsLogUploader(request_context_, server_url,
+                                           mime_type, on_upload_complete));
 }
 
 base::TimeDelta CastMetricsServiceClient::GetStandardUploadInterval() {

chromecast/browser/metrics/cast_metrics_service_client.h

@@ -78,7 +78,10 @@ class CastMetricsServiceClient : public ::metrics::MetricsServiceClient,
   void InitializeSystemProfileMetrics(
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
+  std::string GetMetricsServerUrl() override;
   std::unique_ptr<::metrics::MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
 

components/metrics/metrics_service.cc

@@ -159,6 +159,7 @@
 #include "components/metrics/metrics_reporting_scheduler.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/metrics_state_manager.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"
@@ -1009,6 +1010,8 @@ void MetricsService::SendStagedLog() {
 
   if (!log_uploader_) {
     log_uploader_ = client_->CreateUploader(
+        client_->GetMetricsServerUrl(),
+        metrics::kDefaultMetricsMimeType,
         base::Bind(&MetricsService::OnLogUploadComplete,
                    self_ptr_factory_.GetWeakPtr()));
   }

components/metrics/metrics_service_client.cc

@@ -4,6 +4,8 @@
 
 #include "components/metrics/metrics_service_client.h"
 
+#include "components/metrics/url_constants.h"
+
 namespace metrics {
 
 base::string16 MetricsServiceClient::GetRegistryBackupKey() {
@@ -22,4 +24,8 @@ bool MetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return false;
 }
 
+std::string MetricsServiceClient::GetMetricsServerUrl() {
+  return metrics::kDefaultMetricsServerUrl;
+}
+
 }  // namespace metrics

components/metrics/metrics_service_client.h

@@ -82,9 +82,14 @@ class MetricsServiceClient {
   virtual void CollectFinalMetricsForLog(
       const base::Closure& done_callback) = 0;
 
+  // Get the URL of the metrics server.
+  virtual std::string GetMetricsServerUrl();
+
   // Creates a MetricsLogUploader with the specified parameters (see comments on
   // MetricsLogUploader for details).
   virtual std::unique_ptr<MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) = 0;
 
   // Returns the standard interval between upload attempts.

components/metrics/test_metrics_service_client.cc

@@ -66,6 +66,8 @@ void TestMetricsServiceClient::CollectFinalMetricsForLog(
 }
 
 std::unique_ptr<MetricsLogUploader> TestMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
     const base::Callback<void(int)>& on_upload_complete) {
   return std::unique_ptr<MetricsLogUploader>();
 }

components/metrics/test_metrics_service_client.h

@@ -36,6 +36,8 @@ class TestMetricsServiceClient : public MetricsServiceClient {
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
   std::unique_ptr<MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
   bool IsReportingPolicyManaged() override;

ios/chrome/browser/metrics/ios_chrome_metrics_service_client.h

@@ -58,6 +58,8 @@ class IOSChromeMetricsServiceClient
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
   std::unique_ptr<metrics::MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
   base::string16 GetRegistryBackupKey() override;

ios/chrome/browser/metrics/ios_chrome_metrics_service_client.mm

@@ -151,11 +151,12 @@ void IOSChromeMetricsServiceClient::CollectFinalMetricsForLog(
 
 std::unique_ptr<metrics::MetricsLogUploader>
 IOSChromeMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
     const base::Callback<void(int)>& on_upload_complete) {
   return base::MakeUnique<metrics::NetMetricsLogUploader>(
       GetApplicationContext()->GetSystemURLRequestContext(),
-      metrics::kDefaultMetricsServerUrl, metrics::kDefaultMetricsMimeType,
-      on_upload_complete);
+      server_url, mime_type, on_upload_complete);
 }
 
 base::TimeDelta IOSChromeMetricsServiceClient::GetStandardUploadInterval() {

ios/chrome/today_extension/today_metrics_logger.mm

@@ -67,6 +67,8 @@ class TodayMetricsServiceClient : public metrics::MetricsServiceClient {
       const base::Closure& done_callback) override;
   void CollectFinalMetricsForLog(const base::Closure& done_callback) override;
   std::unique_ptr<metrics::MetricsLogUploader> CreateUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
       const base::Callback<void(int)>& on_upload_complete) override;
   base::TimeDelta GetStandardUploadInterval() override;
 
@@ -149,6 +151,8 @@ void TodayMetricsServiceClient::CollectFinalMetricsForLog(
 
 std::unique_ptr<metrics::MetricsLogUploader>
 TodayMetricsServiceClient::CreateUploader(
+    const std::string& server_url,
+    const std::string& mime_type,
     const base::Callback<void(int)>& on_upload_complete) {
   NOTREACHED();
   return nullptr;