Fix an issue that we didn't clean url request properly.

content/browser/download/download_item_impl_unittest.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.
 
 #include "content/browser/download/download_item_impl.h"
 
 #include <stdint.h>
 
 #include <deque>
 #include <iterator>
@@ skipping 414 matching lines @@
 //  set_* mutators
 
 TEST_F(DownloadItemTest, NotificationAfterUpdate) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
   ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   TestDownloadItemObserver observer(item);
 
   item->DestinationUpdate(kDownloadChunkSize, kDownloadSpeed,
-                          std::vector<DownloadItem::ReceivedSlice>());
+                          std::vector<DownloadItem::ReceivedSlice>(),
+                          std::unordered_set<int64_t>());
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
   EXPECT_EQ(kDownloadSpeed, item->CurrentSpeed());
   CleanupItem(item, file, DownloadItem::IN_PROGRESS);
 }
 
 TEST_F(DownloadItemTest, NotificationAfterCancel) {
   DownloadItemImpl* user_cancel = CreateDownloadItem();
   DownloadTargetCallback target_callback;
   MockDownloadFile* download_file =
       CallDownloadItemStart(user_cancel, &target_callback);
@@ skipping 526 matching lines @@
       DownloadItem::ReceivedSlice(0, 10)};
   create_info()->etag = kFirstETag;
 
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
   EXPECT_CALL(*download_file, Detach());
 
-  item->DestinationObserverAsWeakPtr()->DestinationUpdate(10, 100,
-                                                          kReceivedSlice);
+  item->DestinationObserverAsWeakPtr()->DestinationUpdate(
+      10, 100, kReceivedSlice, std::unordered_set<int64_t>());
   EXPECT_EQ(kReceivedSlice, item->GetReceivedSlices());
   EXPECT_EQ(10, item->GetReceivedBytes());
 
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 0,
       std::unique_ptr<crypto::SecureHash>());
   EXPECT_EQ(kReceivedSlice, item->GetReceivedSlices());
 
   RunAllPendingInMessageLoops();
 
@@ skipping 404 matching lines @@
 
   EXPECT_EQ(0l, item->CurrentSpeed());
   EXPECT_EQ(0l, item->GetReceivedBytes());
   EXPECT_EQ(0l, item->GetTotalBytes());
   EXPECT_FALSE(observer.CheckAndResetDownloadUpdated());
   item->SetTotalBytes(100l);
   EXPECT_EQ(100l, item->GetTotalBytes());
 
   std::vector<DownloadItem::ReceivedSlice> received_slices;
   received_slices.emplace_back(0, 10);
-  as_observer->DestinationUpdate(10, 20, received_slices);
+  as_observer->DestinationUpdate(10, 20, received_slices,
+                                 std::unordered_set<int64_t>());
   EXPECT_EQ(20l, item->CurrentSpeed());
   EXPECT_EQ(10l, item->GetReceivedBytes());
   EXPECT_EQ(100l, item->GetTotalBytes());
   EXPECT_EQ(received_slices, item->GetReceivedSlices());
   EXPECT_TRUE(observer.CheckAndResetDownloadUpdated());
 
   received_slices.emplace_back(200, 100);
-  as_observer->DestinationUpdate(200, 20, received_slices);
+  as_observer->DestinationUpdate(200, 20, received_slices,
+                                 std::unordered_set<int64_t>());
   EXPECT_EQ(20l, item->CurrentSpeed());
   EXPECT_EQ(200l, item->GetReceivedBytes());
   EXPECT_EQ(0l, item->GetTotalBytes());
   EXPECT_EQ(received_slices, item->GetReceivedSlices());
   EXPECT_TRUE(observer.CheckAndResetDownloadUpdated());
 
   CleanupItem(item, file, DownloadItem::IN_PROGRESS);
 }
 
 TEST_F(DownloadItemTest, DestinationError_NoRestartRequired) {
@@ skipping 56 matching lines @@
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
   base::WeakPtr<DownloadDestinationObserver> as_observer(
       item->DestinationObserverAsWeakPtr());
   TestDownloadItemObserver observer(item);
 
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   EXPECT_EQ("", item->GetHash());
   EXPECT_FALSE(item->AllDataSaved());
   EXPECT_FALSE(observer.CheckAndResetDownloadUpdated());
 
-  as_observer->DestinationUpdate(
-      10, 20, std::vector<DownloadItem::ReceivedSlice>());
+  as_observer->DestinationUpdate(10, 20,
+                                 std::vector<DownloadItem::ReceivedSlice>(),
+                                 std::unordered_set<int64_t>());
   EXPECT_TRUE(observer.CheckAndResetDownloadUpdated());
   EXPECT_FALSE(observer.CheckAndResetDownloadUpdated());  // Confirm reset.
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   EXPECT_EQ("", item->GetHash());
   EXPECT_FALSE(item->AllDataSaved());
 
   std::unique_ptr<crypto::SecureHash> hash(
       crypto::SecureHash::Create(crypto::SecureHash::SHA256));
   hash->Update(kTestData1, sizeof(kTestData1));
 
@@ skipping 436 matching lines @@
 // Chromium doesn't allow using std::bind for good reasons.
 void DestinationUpdateInvoker(
     int64_t bytes_so_far,
     int64_t bytes_per_sec,
     base::WeakPtr<DownloadDestinationObserver> observer) {
   DVLOG(20) << "DestinationUpdate(bytes_so_far:" << bytes_so_far
             << ", bytes_per_sec:" << bytes_per_sec
             << ") observer:" << !!observer;
   if (observer) {
     observer->DestinationUpdate(bytes_so_far, bytes_per_sec,
-                                std::vector<DownloadItem::ReceivedSlice>());
+                                std::vector<DownloadItem::ReceivedSlice>(),
+                                std::unordered_set<int64_t>());
   }
 }
 
 void DestinationErrorInvoker(
     DownloadInterruptReason reason,
     int64_t bytes_so_far,
     base::WeakPtr<DownloadDestinationObserver> observer) {
   DVLOG(20) << "DestinationError(reason:"
             << DownloadInterruptReasonToString(reason)
             << ", bytes_so_far:" << bytes_so_far << ") observer:" << !!observer;
@@ skipping 331 matching lines @@
 
   item_->Cancel(true);
   RunAllPendingInMessageLoops();
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content