[attribution_reporting] Clean up copies and moves

Change-Id: I7d3ae1abb81ce428706ad407ee2f0538e5154cd4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3114194
Reviewed-by: John Delaney <johnidel@chromium.org>
Commit-Queue: Andrew Paseltiner <apaseltiner@chromium.org>
Cr-Commit-Position: refs/heads/main@{#914972}

content/browser/conversions/conversion_manager_impl_unittest.cc

@@ -82,7 +82,7 @@ class TestConversionReporter
   }
 
   void SetSentReportInfo(absl::optional<SentReportInfo> info) {
-    sent_report_info_ = info;
+    sent_report_info_ = std::move(info);
   }
 
   size_t num_reports() { return num_reports_; }

content/browser/conversions/conversion_network_sender_impl_unittest.cc

@@ -82,7 +82,9 @@ class ConversionNetworkSenderTest : public testing::Test {
   network::TestURLLoaderFactory test_url_loader_factory_;
 
  private:
-  void OnReportSent(SentReportInfo info) { sent_reports_.push_back(info); }
+  void OnReportSent(SentReportInfo info) {
+    sent_reports_.push_back(std::move(info));
+  }
 
   scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory_;
 };

content/browser/conversions/conversion_reporter_impl_unittest.cc

@@ -52,7 +52,7 @@ class MockNetworkSender : public ConversionReporterImpl::NetworkSender {
     info.conversion_id = *conversion_report.conversion_id;
     info.original_report_time = conversion_report.original_report_time;
     info.http_response_code = 200;
-    std::move(sent_callback).Run(info);
+    std::move(sent_callback).Run(std::move(info));
   }
 
   ConversionReport::Id last_sent_report_id() { return last_sent_report_id_; }

content/browser/conversions/conversion_storage_sql.cc

@@ -733,10 +733,8 @@ std::vector<ConversionReport> ConversionStorageSql::GetConversionsToReport(
                                   expiry_time, *source_type,
                                   attribution_source_priority, impression_id);
 
-    ConversionReport report(std::move(impression), conversion_data,
-                            conversion_time, report_time, conversion_id);
-
-    conversions.push_back(std::move(report));
+    conversions.emplace_back(std::move(impression), conversion_data,
+                             conversion_time, report_time, conversion_id);
   }
 
   if (!statement.Succeeded())
@@ -1155,12 +1153,11 @@ std::vector<StorableImpression> ConversionStorageSql::GetActiveImpressions(
     if (!source_type.has_value())
       continue;
 
-    StorableImpression impression(impression_data, std::move(impression_origin),
-                                  std::move(conversion_origin),
-                                  std::move(reporting_origin), impression_time,
-                                  expiry_time, *source_type,
-                                  attribution_source_priority, impression_id);
-    impressions.push_back(std::move(impression));
+    impressions.emplace_back(impression_data, std::move(impression_origin),
+                             std::move(conversion_origin),
+                             std::move(reporting_origin), impression_time,
+                             expiry_time, *source_type,
+                             attribution_source_priority, impression_id);
   }
   if (!statement.Succeeded())
     return {};

content/browser/conversions/conversion_test_utils.cc

@@ -237,21 +237,18 @@ ImpressionBuilder& ImpressionBuilder::SetData(uint64_t data) {
   return *this;
 }
 
-ImpressionBuilder& ImpressionBuilder::SetImpressionOrigin(
-    const url::Origin& origin) {
-  impression_origin_ = origin;
+ImpressionBuilder& ImpressionBuilder::SetImpressionOrigin(url::Origin origin) {
+  impression_origin_ = std::move(origin);
   return *this;
 }
 
-ImpressionBuilder& ImpressionBuilder::SetConversionOrigin(
-    const url::Origin& origin) {
-  conversion_origin_ = origin;
+ImpressionBuilder& ImpressionBuilder::SetConversionOrigin(url::Origin origin) {
+  conversion_origin_ = std::move(origin);
   return *this;
 }
 
-ImpressionBuilder& ImpressionBuilder::SetReportingOrigin(
-    const url::Origin& origin) {
-  reporting_origin_ = origin;
+ImpressionBuilder& ImpressionBuilder::SetReportingOrigin(url::Origin origin) {
+  reporting_origin_ = std::move(origin);
   return *this;
 }
 
@@ -312,14 +309,14 @@ ConversionBuilder& ConversionBuilder::SetEventSourceTriggerData(
 }
 
 ConversionBuilder& ConversionBuilder::SetConversionDestination(
-    const net::SchemefulSite& conversion_destination) {
-  conversion_destination_ = conversion_destination;
+    net::SchemefulSite conversion_destination) {
+  conversion_destination_ = std::move(conversion_destination);
   return *this;
 }
 
 ConversionBuilder& ConversionBuilder::SetReportingOrigin(
-    const url::Origin& reporting_origin) {
-  reporting_origin_ = reporting_origin;
+    url::Origin reporting_origin) {
+  reporting_origin_ = std::move(reporting_origin);
   return *this;
 }
 

content/browser/conversions/conversion_test_utils.h

@@ -219,7 +219,7 @@ class TestConversionManager : public ConversionManager {
     return last_impression_origin_;
   }
 
-  const absl::optional<int64_t> last_attribution_source_priority() {
+  const absl::optional<int64_t>& last_attribution_source_priority() {
     return last_attribution_source_priority_;
   }
 
@@ -249,14 +249,11 @@ class ImpressionBuilder {
 
   ImpressionBuilder& SetData(uint64_t data) WARN_UNUSED_RESULT;
 
-  ImpressionBuilder& SetImpressionOrigin(const url::Origin& origin)
-      WARN_UNUSED_RESULT;
+  ImpressionBuilder& SetImpressionOrigin(url::Origin origin) WARN_UNUSED_RESULT;
 
-  ImpressionBuilder& SetConversionOrigin(const url::Origin& domain)
-      WARN_UNUSED_RESULT;
+  ImpressionBuilder& SetConversionOrigin(url::Origin domain) WARN_UNUSED_RESULT;
 
-  ImpressionBuilder& SetReportingOrigin(const url::Origin& origin)
-      WARN_UNUSED_RESULT;
+  ImpressionBuilder& SetReportingOrigin(url::Origin origin) WARN_UNUSED_RESULT;
 
   ImpressionBuilder& SetSourceType(StorableImpression::SourceType source_type)
       WARN_UNUSED_RESULT;
@@ -303,9 +300,9 @@ class ConversionBuilder {
       uint64_t event_source_trigger_data) WARN_UNUSED_RESULT;
 
   ConversionBuilder& SetConversionDestination(
-      const net::SchemefulSite& conversion_destination) WARN_UNUSED_RESULT;
+      net::SchemefulSite conversion_destination) WARN_UNUSED_RESULT;
 
-  ConversionBuilder& SetReportingOrigin(const url::Origin& reporting_origin)
+  ConversionBuilder& SetReportingOrigin(url::Origin reporting_origin)
       WARN_UNUSED_RESULT;
 
   ConversionBuilder& SetPriority(int64_t priority) WARN_UNUSED_RESULT;

content/browser/conversions/conversions_browsertest.cc

@@ -41,14 +41,14 @@ namespace {
 struct ExpectedReportWaiter {
   // ControllableHTTPResponses can only wait for relative urls, so only supply
   // the path.
-  ExpectedReportWaiter(const GURL& report_url,
-                       const std::string body,
+  ExpectedReportWaiter(GURL report_url,
+                       std::string body,
                        net::EmbeddedTestServer* server)
-      : expected_url(report_url),
-        expected_body(body),
+      : expected_url(std::move(report_url)),
+        expected_body(std::move(body)),
         response(std::make_unique<net::test_server::ControllableHttpResponse>(
             server,
-            report_url.path())) {}
+            expected_url.path())) {}
 
   GURL expected_url;
   std::string expected_body;

content/browser/conversions/rate_limit_table_unittest.cc

@@ -39,21 +39,22 @@ class RateLimitTableTest : public testing::Test {
   }
 
   ConversionReport NewConversionReport(
-      const url::Origin& impression_origin,
-      const url::Origin& conversion_origin,
+      url::Origin impression_origin,
+      url::Origin conversion_origin,
       StorableImpression::Id impression_id = StorableImpression::Id(0),
       StorableImpression::SourceType source_type =
           StorableImpression::SourceType::kNavigation) {
-    return ConversionReport(ImpressionBuilder(clock()->Now())
-                                .SetImpressionOrigin(impression_origin)
-                                .SetConversionOrigin(conversion_origin)
-                                .SetImpressionId(impression_id)
-                                .SetSourceType(source_type)
-                                .Build(),
-                            /*conversion_data=*/0,
-                            /*conversion_time=*/clock()->Now(),
-                            /*report_time=*/clock()->Now(),
-                            /*conversion_id=*/absl::nullopt);
+    return ConversionReport(
+        ImpressionBuilder(clock()->Now())
+            .SetImpressionOrigin(std::move(impression_origin))
+            .SetConversionOrigin(std::move(conversion_origin))
+            .SetImpressionId(impression_id)
+            .SetSourceType(source_type)
+            .Build(),
+        /*conversion_data=*/0,
+        /*conversion_time=*/clock()->Now(),
+        /*report_time=*/clock()->Now(),
+        /*conversion_id=*/absl::nullopt);
   }
 
   size_t GetRateLimitRows(sql::Database* db) {

content/browser/conversions/sent_report_info.cc

@@ -14,7 +14,7 @@ SentReportInfo::SentReportInfo(ConversionReport::Id conversion_id,
                                bool should_retry)
     : conversion_id(conversion_id),
       original_report_time(original_report_time),
-      report_url(report_url),
+      report_url(std::move(report_url)),
       report_body(std::move(report_body)),
       http_response_code(http_response_code),
       should_retry(should_retry) {}