Remove extra copy operations identified by Coverity

Change-Id: I5e900082d3b17300f3a4ef95561d04c0228aba4f

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -95,7 +95,9 @@ class UsagePropertySet : public CdmClientPropertySet {
 
 CdmEngine::CdmEngine(wvutil::FileSystem* file_system,
                      std::shared_ptr<metrics::EngineMetrics> metrics)
-    : metrics_(metrics), file_system_(file_system), spoid_(EMPTY_SPOID) {
+    : metrics_(std::move(metrics)),
+      file_system_(file_system),
+      spoid_(EMPTY_SPOID) {
   assert(file_system);
   Properties::Init();
 }
@@ -712,7 +714,7 @@ CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
       LOGW("GetWVCdmVersion failed");
       return CdmResponseType(UNKNOWN_ERROR);
     }
-    *query_response = cdm_version;
+    *query_response = std::move(cdm_version);
     return CdmResponseType(NO_ERROR);
   }
   if (query_token == QUERY_KEY_RESOURCE_RATING_TIER) {
@@ -933,7 +935,7 @@ CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
     metrics_->GetCryptoMetrics()
         ->crypto_session_get_device_unique_id_.Increment(status);
     if (status != NO_ERROR) return status;
-    *query_response = device_id;
+    *query_response = std::move(device_id);
     return CdmResponseType(NO_ERROR);
   }
   if (query_token == QUERY_KEY_PROVISIONING_ID) {
@@ -943,7 +945,7 @@ CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
       LOGW("GetProvisioningId failed: status = %d", static_cast<int>(status));
       return status;
     }
-    *query_response = provisioning_id;
+    *query_response = std::move(provisioning_id);
     return CdmResponseType(NO_ERROR);
   }
   LOGW("Unknown status requested: query_token = %s", IdToString(query_token));

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -70,7 +70,7 @@ int DrmKeyTypeToMetricValue(CryptoWrappedKey::Type type) {
 
 CdmSession::CdmSession(wvutil::FileSystem* file_system,
                        std::shared_ptr<metrics::SessionMetrics> metrics)
-    : metrics_(metrics),
+    : metrics_(std::move(metrics)),
       initialized_(false),
       closed_(true),
       file_handle_(new DeviceFiles(file_system)),

libwvdrmengine/cdm/core/src/policy_engine.cpp

@@ -30,7 +30,7 @@ namespace wvcdm {
 PolicyEngine::PolicyEngine(CdmSessionId session_id,
                            WvCdmEventListener* event_listener,
                            CryptoSession* crypto_session)
-    : session_id_(session_id),
+    : session_id_(std::move(session_id)),
       event_listener_(event_listener),
       license_keys_(new LicenseKeys(crypto_session->GetSecurityLevel())),
       clock_(new wvutil::Clock()) {

libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp

@@ -56,7 +56,7 @@ class MockCdmEngineImpl : public CdmEngine {
  public:
   MockCdmEngineImpl(wvutil::FileSystem* file_system,
                     std::shared_ptr<EngineMetrics> metrics)
-      : CdmEngine(file_system, metrics) {}
+      : CdmEngine(file_system, std::move(metrics)) {}
   MOCK_METHOD(CdmResponseType, OpenSession,
               (const CdmKeySystem&, CdmClientPropertySet*, const CdmSessionId&,
                WvCdmEventListener*),
@@ -119,7 +119,7 @@ class WvCdmEngineMetricsImplTest : public ::testing::Test {
     std::shared_ptr<EngineMetrics> engine_metrics(new EngineMetrics);
     test_cdm_metrics_engine_.reset(
         new CdmEngineMetricsImpl<StrictMock<MockCdmEngineImpl>>(
-            file_system_.get(), engine_metrics));
+            file_system_.get(), std::move(engine_metrics)));
   }
 
  protected:

libwvdrmengine/cdm/core/test/cdm_usage_table_unittest.cpp

@@ -794,8 +794,8 @@ TEST_P(CdmUsageTableInitializationTest, RestoreUsageTable_AtCapacity) {
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
-                      SetArgPointee<1>(usage_entries), SetArgPointee<2>(false),
+                      SetArgPointee<1>(std::move(usage_entries)),
-                      Return(true)));
+                      SetArgPointee<2>(false), Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
@@ -822,8 +822,8 @@ TEST_P(CdmUsageTableInitializationTest,
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
-                      SetArgPointee<1>(usage_entries), SetArgPointee<2>(false),
+                      SetArgPointee<1>(std::move(usage_entries)),
-                      Return(true)));
+                      SetArgPointee<2>(false), Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
@@ -3588,7 +3588,7 @@ TEST_F(CdmUsageTableTest, StaleHeader) {
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
-                      SetArgPointee<1>(entry_info_list),
+                      SetArgPointee<1>(std::move(entry_info_list)),
                       SetArgPointee<2>(false), Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUsageTableHeader))

libwvdrmengine/cdm/core/test/device_files_unittest.cpp

@@ -5206,7 +5206,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
   EXPECT_CALL(file_system, Open(StrEq(license_path), IsCreateFileFlagSet()))
       .WillOnce(Return(ByMove(std::unique_ptr<File>(file))));
   EXPECT_CALL(*file, Write(_, _))
-      .With(AllArgs(StrAndLenContains(expected_substrings)))
+      .With(AllArgs(StrAndLenContains(std::move(expected_substrings))))
       .WillOnce(ReturnArg<1>());
   EXPECT_CALL(*file, Read(_, _)).Times(0);
 
@@ -5226,7 +5226,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
       kLicenseTestData[license_num].playback_start_time,
       kLicenseTestData[license_num].last_playback_time,
       kLicenseTestData[license_num].grace_period_end_time,
-      app_parameters,
+      std::move(app_parameters),
       kLicenseTestData[license_num].usage_entry,
       kLicenseTestData[license_num].usage_entry_index,
       kLicenseTestData[license_num].drm_certificate,
@@ -5271,7 +5271,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
         .WillOnce(Return(ByMove(std::unique_ptr<File>(file))));
 
     EXPECT_CALL(*file, Write(_, _))
-        .With(AllArgs(StrAndLenContains(expected_substrings)))
+        .With(AllArgs(StrAndLenContains(std::move(expected_substrings))))
         .WillOnce(ReturnArg<1>());
     EXPECT_CALL(*file, Read(_, _)).Times(0);
   }
@@ -5295,7 +5295,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
         kLicenseTestData[i].playback_start_time,
         kLicenseTestData[i].last_playback_time,
         kLicenseTestData[i].grace_period_end_time,
-        app_parameters,
+        std::move(app_parameters),
         kLicenseTestData[i].usage_entry,
         kLicenseTestData[i].usage_entry_index,
         kLicenseTestData[i].drm_certificate,
@@ -5980,7 +5980,7 @@ TEST_P(DeviceFilesUsageInfoListTest, UsageInfoList) {
   }
 
   EXPECT_CALL(file_system, List(StrEq(device_base_path_), NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>(file_list), Return(true)));
+      .WillOnce(DoAll(SetArgPointee<1>(std::move(file_list)), Return(true)));
 
   DeviceFiles device_files(&file_system);
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
@@ -6030,7 +6030,7 @@ TEST_P(DeviceFilesUsageInfoTest, Store) {
   EXPECT_CALL(file_system, Open(StrEq(path), _))
       .WillOnce(Return(ByMove(std::unique_ptr<File>(file))));
   EXPECT_CALL(*file, Write(_, _))
-      .With(AllArgs(StrAndLenContains(usage_data_fields)))
+      .With(AllArgs(StrAndLenContains(std::move(usage_data_fields))))
       .WillOnce(ReturnArg<1>());
 
   DeviceFiles device_files(&file_system);
@@ -6336,7 +6336,7 @@ TEST_P(DeviceFilesUsageInfoTest, UpdateUsageInfo) {
         .WillOnce(Return(ByMove(std::unique_ptr<File>(next_file))));
 
     EXPECT_CALL(*next_file, Write(_, _))
-        .With(AllArgs(StrAndLenContains(usage_data_fields)))
+        .With(AllArgs(StrAndLenContains(std::move(usage_data_fields))))
         .WillOnce(ReturnArg<1>());
   }
 
@@ -6451,7 +6451,7 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
   EXPECT_CALL(file_system, Open(StrEq(path), _))
       .WillOnce(Return(ByMove(std::unique_ptr<File>(file))));
   EXPECT_CALL(*file, Write(_, _))
-      .With(AllArgs(StrAndLenContains(entry_data)))
+      .With(AllArgs(StrAndLenContains(std::move(entry_data))))
       .WillOnce(ReturnArg<1>());
   EXPECT_CALL(*file, Read(_, _)).Times(0);
 

libwvdrmengine/cdm/core/test/license_unittest.cpp

@@ -619,7 +619,7 @@ TEST_P(CdmLicenseEntitledKeyTest, LoadsEntitledKeys) {
   CreateCdmLicense();
   EXPECT_TRUE(cdm_license_->Init(true, kDefaultServiceCertificate,
                                  crypto_session_, policy_engine_));
-  cdm_license_->set_entitlement_keys(entitlement_license);
+  cdm_license_->set_entitlement_keys(std::move(entitlement_license));
 
   // Call the function under test and check its return value
   CdmResponseType ret = cdm_license_->HandleNewEntitledKeys(entitled_keys);

libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp

@@ -210,11 +210,12 @@ class PolicyEngineTest : public WvCdmTestBase {
   void ExpectSessionKeysChange(CdmKeyStatus expected_key_status,
                                bool expected_has_new_usable_key,
                                KeyId expected_keyid) {
-    EXPECT_CALL(mock_event_listener_,
+    EXPECT_CALL(
-                OnSessionKeysChange(kSessionId,
+        mock_event_listener_,
-                                    UnorderedElementsAre(Pair(
+        OnSessionKeysChange(kSessionId,
-                                        expected_keyid, expected_key_status)),
+                            UnorderedElementsAre(Pair(std::move(expected_keyid),
-                                    expected_has_new_usable_key));
+                                                      expected_key_status)),
+                            expected_has_new_usable_key));
   }
 
   void ExpectSessionKeysChange(CdmKeyStatus expected_key1_status,

libwvdrmengine/cdm/core/test/test_base.h

@@ -109,7 +109,7 @@ class TestCdmEngine : public CdmEngine {
  public:
   TestCdmEngine(wvutil::FileSystem* file_system,
                 std::shared_ptr<metrics::EngineMetrics> metrics)
-      : CdmEngine(file_system, metrics) {}
+      : CdmEngine(file_system, std::move(metrics)) {}
   const CdmSession* GetCdmSession(std::string sessionId) const;
 };
 

libwvdrmengine/cdm/core/test/url_request.cpp

@@ -120,7 +120,7 @@ bool UrlRequest::GetResponse(std::string* message) {
     }
   }
 
-  ConcatenateChunkedResponse(response, message);
+  ConcatenateChunkedResponse(std::move(response), message);
   LOGV("HTTP response from %s: (%zu): %s", socket_.url().c_str(),
        message->size(), message->c_str());
   return true;