Support the profile report in ReportUploader

ReportUploader can now accept requests with different report type and
call associated CloudPolicyClient API.

Bug: 1261945
Change-Id: I127359f1f07764a4d4e6f39ae689c74834719cac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3365665
Reviewed-by: Fabio Tirelo <ftirelo@chromium.org>
Commit-Queue: Owen Min <zmin@chromium.org>
Cr-Commit-Position: refs/heads/main@{#956551}

chrome/browser/enterprise/reporting/report_scheduler_unittest.cc

@@ -104,7 +104,8 @@ class MockReportUploader : public ReportUploader {
   MockReportUploader& operator=(const MockReportUploader&) = delete;
 
   ~MockReportUploader() override = default;
-  MOCK_METHOD2(SetRequestAndUpload, void(ReportRequestQueue, ReportCallback));
+  MOCK_METHOD3(SetRequestAndUpload,
+               void(ReportType, ReportRequestQueue, ReportCallback));
 };
 
 class MockRealTimeReportGenerator : public RealTimeReportGenerator {
@@ -313,8 +314,8 @@ TEST_F(ReportSchedulerTest, UploadReportSucceeded) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -334,8 +335,8 @@ TEST_F(ReportSchedulerTest, UploadReportTransientError) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kTransientError));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kTransientError));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -355,8 +356,8 @@ TEST_F(ReportSchedulerTest, UploadReportPersistentError) {
   EXPECT_CALL_SetupRegistrationWithSetDMToken();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kPersistentError));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kPersistentError));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -381,7 +382,7 @@ TEST_F(ReportSchedulerTest, NoReportGenerate) {
   EXPECT_CALL_SetupRegistrationWithSetDMToken();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(0)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _)).Times(0);
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _, _)).Times(0);
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -409,8 +410,8 @@ TEST_F(ReportSchedulerTest, TimerDelayWithLastUploadTimestamp) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -429,8 +430,8 @@ TEST_F(ReportSchedulerTest, TimerDelayWithoutLastUploadTimestamp) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -466,8 +467,8 @@ TEST_F(ReportSchedulerTest, ReportingIsDisabledWhileNewReportIsPosted) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -502,8 +503,9 @@ TEST_F(ReportSchedulerTest, OnUpdate) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kBrowserVersion, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_,
+              SetRequestAndUpload(ReportType::kBrowserVersion, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   g_browser_process->GetBuildState()->SetUpdate(
@@ -525,8 +527,9 @@ TEST_F(ReportSchedulerTest, OnUpdateAndPersistentError) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kBrowserVersion, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kPersistentError));
+  EXPECT_CALL(*uploader_,
+              SetRequestAndUpload(ReportType::kBrowserVersion, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kPersistentError));
 
   CreateScheduler();
   g_browser_process->GetBuildState()->SetUpdate(
@@ -559,8 +562,10 @@ TEST_F(ReportSchedulerTest, DeferredTimer) {
 
   // Hang on to the uploader's ReportCallback.
   ReportUploader::ReportCallback saved_callback;
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce([&saved_callback](ReportRequestQueue requests,
+  EXPECT_CALL(*uploader_,
+              SetRequestAndUpload(ReportType::kBrowserVersion, _, _))
+      .WillOnce([&saved_callback](ReportType report_type,
+                                  ReportRequestQueue requests,
                                   ReportUploader::ReportCallback callback) {
         saved_callback = std::move(callback);
       });
@@ -582,8 +587,8 @@ TEST_F(ReportSchedulerTest, DeferredTimer) {
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
   auto new_uploader = std::make_unique<MockReportUploader>();
-  EXPECT_CALL(*new_uploader, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*new_uploader, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
   std::move(saved_callback).Run(ReportUploader::kSuccess);
   ExpectLastUploadTimestampUpdated(false);
   ::testing::Mock::VerifyAndClearExpectations(generator_);
@@ -612,8 +617,9 @@ TEST_F(ReportSchedulerTest, OnNewVersion) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kBrowserVersion, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_,
+              SetRequestAndUpload(ReportType::kBrowserVersion, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
 
@@ -642,8 +648,8 @@ TEST_F(ReportSchedulerTest, OnNewVersionRegularReport) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
 
@@ -664,7 +670,7 @@ TEST_F(ReportSchedulerTest, OnNewVersionRegularReport) {
 TEST_F(ReportSchedulerTest, ExtensionRequestWithRealTimePipeline) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(_, _)).Times(0);
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _)).Times(0);
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _, _)).Times(0);
 
   Profile* profile = profile_manager_.CreateTestingProfile("profile");
 

components/enterprise/browser/reporting/report_scheduler.cc

@@ -65,6 +65,21 @@ void OnExtensionRequestEnqueued(bool success) {
     LOG(ERROR) << "Extension request failed to be added to the pipeline.";
 }
 
+ReportType TriggerToReportType(ReportScheduler::ReportTrigger trigger) {
+  switch (trigger) {
+    case ReportScheduler::kTriggerNone:
+    case ReportScheduler::kTriggerExtensionRequestRealTime:
+      NOTREACHED();
+      [[fallthrough]];
+    case ReportScheduler::kTriggerTimer:
+      return ReportType::kFull;
+    case ReportScheduler::kTriggerUpdate:
+      return ReportType::kBrowserVersion;
+    case ReportScheduler::kTriggerNewVersion:
+      return ReportType::kBrowserVersion;
+  }
+}
+
 }  // namespace
 
 ReportScheduler::Delegate::Delegate() = default;
@@ -229,28 +244,11 @@ void ReportScheduler::GenerateAndUploadReport(ReportTrigger trigger) {
   }
 
   active_trigger_ = trigger;
-  ReportType report_type = ReportType::kFull;
-  switch (trigger) {
-    case kTriggerNone:
-    case kTriggerExtensionRequestRealTime:
-      NOTREACHED();
-      [[fallthrough]];
-    case kTriggerTimer:
-      VLOG(1) << "Generating enterprise report.";
-      break;
-    case kTriggerUpdate:
-      VLOG(1) << "Generating basic enterprise report upon update.";
-      report_type = ReportType::kBrowserVersion;
-      break;
-    case kTriggerNewVersion:
-      VLOG(1) << "Generating basic enterprise report upon new version.";
-      report_type = ReportType::kBrowserVersion;
-      break;
-  }
 
   report_generator_->Generate(
-      report_type, base::BindOnce(&ReportScheduler::OnReportGenerated,
-                                  base::Unretained(this)));
+      TriggerToReportType(trigger),
+      base::BindOnce(&ReportScheduler::OnReportGenerated,
+                     base::Unretained(this)));
 }
 
 void ReportScheduler::GenerateAndUploadRealtimeReport(
@@ -280,8 +278,9 @@ void ReportScheduler::OnReportGenerated(ReportRequestQueue requests) {
   }
   RecordUploadTrigger(active_trigger_);
   report_uploader_->SetRequestAndUpload(
-      std::move(requests), base::BindOnce(&ReportScheduler::OnReportUploaded,
-                                          base::Unretained(this)));
+      TriggerToReportType(active_trigger_), std::move(requests),
+      base::BindOnce(&ReportScheduler::OnReportUploaded,
+                     base::Unretained(this)));
 }
 
 void ReportScheduler::OnReportUploaded(ReportUploader::ReportStatus status) {

components/enterprise/browser/reporting/report_uploader.cc

@@ -9,6 +9,7 @@
 #include "base/metrics/histogram_functions.h"
 #include "base/time/time.h"
 #include "build/chromeos_buildflags.h"
+#include "components/enterprise/browser/reporting/report_type.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "device_management_backend.pb.h"
 
@@ -41,8 +42,10 @@ ReportUploader::ReportUploader(policy::CloudPolicyClient* client,
       maximum_number_of_retries_(maximum_number_of_retries) {}
 ReportUploader::~ReportUploader() = default;
 
-void ReportUploader::SetRequestAndUpload(ReportRequestQueue requests,
+void ReportUploader::SetRequestAndUpload(ReportType report_type,
+                                         ReportRequestQueue requests,
                                          ReportCallback callback) {
+  report_type_ = report_type;
   requests_ = std::move(requests);
   callback_ = std::move(callback);
   Upload();
@@ -52,17 +55,28 @@ void ReportUploader::Upload() {
   auto callback = base::BindRepeating(&ReportUploader::OnRequestFinished,
                                       weak_ptr_factory_.GetWeakPtr());
 
+  switch (report_type_) {
+    case ReportType::kFull:
+    case ReportType::kBrowserVersion: {
+      auto request = std::make_unique<ReportRequest::DeviceReportRequestProto>(
+          requests_.front()->GetDeviceReportRequest());
 #if BUILDFLAG(IS_CHROMEOS_ASH)
-  auto request =
-      std::make_unique<enterprise_management::ChromeOsUserReportRequest>(
-          requests_.front()->GetDeviceReportRequest());
-  client_->UploadChromeOsUserReport(std::move(request), std::move(callback));
+      client_->UploadChromeOsUserReport(std::move(request),
+                                        std::move(callback));
 #else
-  auto request =
-      std::make_unique<enterprise_management::ChromeDesktopReportRequest>(
-          requests_.front()->GetDeviceReportRequest());
-  client_->UploadChromeDesktopReport(std::move(request), std::move(callback));
+      client_->UploadChromeDesktopReport(std::move(request),
+                                         std::move(callback));
 #endif
+      break;
+    }
+    case ReportType::kProfileReport: {
+      client_->UploadChromeProfileReport(
+          std::make_unique<em::ChromeProfileReportRequest>(
+              requests_.front()->GetChromeProfileReportRequest()),
+          std::move(callback));
+      break;
+    }
+  }
 }  // BUILDFLAG(IS_CHROMEOS_ASH)
 
 void ReportUploader::OnRequestFinished(bool status) {

components/enterprise/browser/reporting/report_uploader.h

@@ -53,7 +53,8 @@ class ReportUploader {
 
   // Sets a list of requests and upload it. Request will be uploaded one after
   // another.
-  virtual void SetRequestAndUpload(ReportRequestQueue requests,
+  virtual void SetRequestAndUpload(ReportType report_type,
+                                   ReportRequestQueue requests,
                                    ReportCallback callback);
 
  private:
@@ -77,6 +78,7 @@ class ReportUploader {
   raw_ptr<policy::CloudPolicyClient> client_;
   ReportCallback callback_;
   ReportRequestQueue requests_;
+  ReportType report_type_;
 
   net::BackoffEntry backoff_entry_;
   base::OneShotTimer backoff_request_timer_;

components/enterprise/browser/reporting/report_uploader_unittest.cc

@@ -13,6 +13,7 @@
 #include "components/enterprise/browser/reporting/report_request.h"
 #include "components/enterprise/browser/reporting/report_type.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
+#include "device_management_backend.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -59,19 +60,31 @@ class ReportUploaderTest : public ::testing::Test {
         << "Please update kBrowserVersionNames above.";
     ReportRequestQueue requests;
     for (int i = 0; i < number_of_request; i++) {
-      auto request = std::make_unique<ReportRequest>(ReportType::kFull);
-      request->GetDeviceReportRequest()
-          .mutable_browser_report()
-          ->set_browser_version(kBrowserVersionNames[i]);
+      auto request = std::make_unique<ReportRequest>(GetReportType());
+      em::BrowserReport* browser_report;
+      switch (GetReportType()) {
+        case ReportType::kFull:
+        case ReportType::kBrowserVersion:
+          browser_report =
+              request->GetDeviceReportRequest().mutable_browser_report();
+          break;
+        case ReportType::kProfileReport:
+          browser_report =
+              request->GetChromeProfileReportRequest().mutable_browser_report();
+          break;
+      }
+      browser_report->set_browser_version(kBrowserVersionNames[i]);
       requests.push(std::move(request));
     }
     has_responded_ = false;
     uploader_->SetRequestAndUpload(
-        std::move(requests),
+        GetReportType(), std::move(requests),
         base::BindOnce(&ReportUploaderTest::OnReportUploaded,
                        base::Unretained(this), expected_status));
   }
 
+  virtual ReportType GetReportType() { return ReportType::kFull; }
+
   void OnReportUploaded(ReportUploader::ReportStatus expected_status,
                         ReportUploader::ReportStatus actuall_status) {
     EXPECT_EQ(expected_status, actuall_status);
@@ -104,7 +117,7 @@ class ReportUploaderTest : public ::testing::Test {
   base::test::TaskEnvironment task_environment_;
 
   std::unique_ptr<ReportUploader> uploader_;
-  policy::MockCloudPolicyClient client_;
+  ::testing::StrictMock<policy::MockCloudPolicyClient> client_;
   bool has_responded_ = false;
   base::HistogramTester histogram_tester_;
 };
@@ -113,17 +126,12 @@ class ReportUploaderTestWithTransientError
     : public ReportUploaderTest,
       public ::testing::WithParamInterface<policy::DeviceManagementStatus> {};
 
-TEST_F(ReportUploaderTest, Success) {
-  EXPECT_CALL(client_, UploadReportProxy(_, _))
-      .WillOnce(WithArgs<1>(policy::ScheduleStatusCallback(true)));
-  UploadReportAndSetExpectation(/*number_of_request=*/1,
-                                ReportUploader::kSuccess);
-  RunNextTask();
-  EXPECT_TRUE(has_responded_);
-  histogram_tester_.ExpectUniqueSample(
-      kResponseMetricsName, ReportResponseMetricsStatus::kSuccess, 1);
-  ::testing::Mock::VerifyAndClearExpectations(&client_);
-}
+class ReportUploaderTestWithReportType
+    : public ReportUploaderTest,
+      public ::testing::WithParamInterface<ReportType> {
+ public:
+  ReportType GetReportType() override { return GetParam(); }
+};
 
 TEST_F(ReportUploaderTest, PersistentError) {
   CreateUploader(/* retry_count = */ 1);
@@ -304,4 +312,32 @@ INSTANTIATE_TEST_SUITE_P(
                       policy::DM_STATUS_TEMPORARY_UNAVAILABLE,
                       policy::DM_STATUS_SERVICE_TOO_MANY_REQUESTS));
 
+TEST_P(ReportUploaderTestWithReportType, Success) {
+  switch (GetReportType()) {
+    case ReportType::kFull:
+    case ReportType::kBrowserVersion:
+      EXPECT_CALL(client_, UploadReportProxy(_, _))
+          .WillOnce(WithArgs<1>(policy::ScheduleStatusCallback(true)));
+      break;
+    case ReportType::kProfileReport:
+      EXPECT_CALL(client_, UploadChromeProfileReportProxy(_, _))
+          .WillOnce(WithArgs<1>(policy::ScheduleStatusCallback(true)));
+      break;
+  }
+
+  UploadReportAndSetExpectation(/*number_of_request=*/1,
+                                ReportUploader::kSuccess);
+  RunNextTask();
+  EXPECT_TRUE(has_responded_);
+  histogram_tester_.ExpectUniqueSample(
+      kResponseMetricsName, ReportResponseMetricsStatus::kSuccess, 1);
+  ::testing::Mock::VerifyAndClearExpectations(&client_);
+}
+
+INSTANTIATE_TEST_SUITE_P(All,
+                         ReportUploaderTestWithReportType,
+                         ::testing::Values(ReportType::kFull,
+                                           ReportType::kBrowserVersion,
+                                           ReportType::kProfileReport));
+
 }  // namespace enterprise_reporting

components/policy/core/common/cloud/mock_cloud_policy_client.h

@@ -13,6 +13,7 @@
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
 #include "components/reporting/proto/synced/record.pb.h"
+#include "device_management_backend.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace network {
@@ -101,6 +102,17 @@ class MockCloudPolicyClient : public CloudPolicyClient {
                void(enterprise_management::ChromeOsUserReportRequest*,
                     StatusCallback&));
 
+  void UploadChromeProfileReport(
+      std::unique_ptr<enterprise_management::ChromeProfileReportRequest>
+          request,
+      StatusCallback callback) override {
+    UploadChromeProfileReportProxy(request.get(), callback);
+  }
+  // Use Proxy function because unique_ptr can't be used in mock function.
+  MOCK_METHOD2(UploadChromeProfileReportProxy,
+               void(enterprise_management::ChromeProfileReportRequest*,
+                    StatusCallback&));
+
   void UploadSecurityEventReport(content::BrowserContext* context,
                                  bool include_device_info,
                                  base::Value value,

ios/chrome/browser/policy/reporting/report_scheduler_ios_unittest.mm

@@ -72,7 +72,8 @@ class MockReportUploader : public ReportUploader {
   MockReportUploader& operator=(const MockReportUploader&) = delete;
   ~MockReportUploader() override = default;
 
-  MOCK_METHOD2(SetRequestAndUpload, void(ReportRequestQueue, ReportCallback));
+  MOCK_METHOD3(SetRequestAndUpload,
+               void(ReportType, ReportRequestQueue, ReportCallback));
 };
 
 class ReportSchedulerIOSTest : public PlatformTest {
@@ -193,8 +194,8 @@ TEST_F(ReportSchedulerIOSTest, UploadReportSucceeded) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -214,8 +215,8 @@ TEST_F(ReportSchedulerIOSTest, UploadReportTransientError) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kTransientError));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kTransientError));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -235,8 +236,8 @@ TEST_F(ReportSchedulerIOSTest, UploadReportPersistentError) {
   EXPECT_CALL_SetupRegistrationWithSetDMToken();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kPersistentError));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kPersistentError));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -261,7 +262,7 @@ TEST_F(ReportSchedulerIOSTest, NoReportGenerate) {
   EXPECT_CALL_SetupRegistrationWithSetDMToken();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(0)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _)).Times(0);
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _, _)).Times(0);
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -289,8 +290,8 @@ TEST_F(ReportSchedulerIOSTest, TimerDelayWithLastUploadTimestamp) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -309,8 +310,8 @@ TEST_F(ReportSchedulerIOSTest, TimerDelayWithoutLastUploadTimestamp) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());
@@ -346,8 +347,8 @@ TEST_F(ReportSchedulerIOSTest, ReportingIsDisabledWhileNewReportIsPosted) {
   EXPECT_CALL_SetupRegistration();
   EXPECT_CALL(*generator_, OnGenerate(ReportType::kFull, _))
       .WillOnce(WithArgs<1>(ScheduleGeneratorCallback(1)));
-  EXPECT_CALL(*uploader_, SetRequestAndUpload(_, _))
-      .WillOnce(RunOnceCallback<1>(ReportUploader::kSuccess));
+  EXPECT_CALL(*uploader_, SetRequestAndUpload(ReportType::kFull, _, _))
+      .WillOnce(RunOnceCallback<2>(ReportUploader::kSuccess));
 
   CreateScheduler();
   EXPECT_TRUE(scheduler_->IsNextReportScheduledForTesting());