Persist download interrupt reason, both target and current paths, and url_chain.

chrome/browser/download/save_page_browsertest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 273 matching lines @@
       std::vector<DownloadPersistentStoreInfo>* entries) {
     history_entries_ = *entries;
 
     // Indicate thet we have received the history and can continue.
     MessageLoopForUI::current()->Quit();
   }
 
   struct DownloadPersistentStoreInfoMatch
     : public std::unary_function<DownloadPersistentStoreInfo, bool> {
 
-    DownloadPersistentStoreInfoMatch(const GURL& url,
-                                     const FilePath& path,
+    DownloadPersistentStoreInfoMatch(const std::vector<GURL>& url_chain,
+                                     const FilePath& target_path,
                                      int64 num_files,
                                      DownloadItem::DownloadState state)
-      : url_(url),
-        path_(path),
+      : url_chain_(url_chain),
+        target_path_(target_path),
         num_files_(num_files),
         state_(state) {}
 
     bool operator() (const DownloadPersistentStoreInfo& info) const {
-      return info.url == url_ &&
-             info.path == path_ &&
+      return info.url_chain == url_chain_ &&
+             info.target_path == target_path_ &&
              // For non-MHTML save packages, received_bytes is actually the
              // number of files.
              ((num_files_ < 0) ||
               (info.received_bytes == num_files_)) &&
              info.total_bytes == 0 &&
              info.state == state_;
     }
 
-    GURL url_;
-    FilePath path_;
+    std::vector<GURL> url_chain_;
+    FilePath target_path_;
     int64 num_files_;
     DownloadItem::DownloadState state_;
   };
 
   void CheckDownloadHistory(const GURL& url,
-                            const FilePath& path,
+                            const FilePath& target_path,
                             int64 num_files,
                             DownloadItem::DownloadState state) {
     // Make sure the relevant download item made it into the history.
     std::vector<DownloadItem*> downloads;
     GetDownloadManager()->GetAllDownloads(&downloads);
     ASSERT_EQ(1u, downloads.size());
 
     QueryDownloadHistory();
 
+    std::vector<GURL> url_chain;
+    url_chain.push_back(url);
     std::vector<DownloadPersistentStoreInfo>::iterator found =
       std::find_if(history_entries_.begin(), history_entries_.end(),
-                   DownloadPersistentStoreInfoMatch(url, path, num_files,
-                                                    state));
+                   DownloadPersistentStoreInfoMatch(
+                       url_chain, target_path, num_files, state));
 
     if (found == history_entries_.end()) {
-      LOG(ERROR) << "Missing url=" << url.spec()
-                 << " path=" << path.value()
+      LOG(ERROR) << "Missing target_path=" << target_path.value()
                  << " received=" << num_files
                  << " state=" << state;
       for (size_t index = 0; index < history_entries_.size(); ++index) {
         LOG(ERROR) << "History@" << index << ": url="
-                   << history_entries_[index].url.spec()
-                   << " path=" << history_entries_[index].path.value()
+                   << "<url chain>"
+                   << " target_path="
+                   << history_entries_[index].target_path.value()
                    << " received=" << history_entries_[index].received_bytes
                    << " total=" << history_entries_[index].total_bytes
                    << " state=" << history_entries_[index].state;
       }
       EXPECT_TRUE(false);
     }
   }
 
   std::vector<DownloadPersistentStoreInfo> history_entries_;
 
@@ skipping 239 matching lines @@
   EXPECT_EQ(url, output_url);
 
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
   // a.htm is 1 file.
   CheckDownloadHistory(url, full_file_name, 1, DownloadItem::COMPLETE);
 
   EXPECT_EQ(GetDownloadManager()->RemoveAllDownloads(), 1);
 
   // Should not be in history.
   QueryDownloadHistory();
+  std::vector<GURL> url_chain;
+  url_chain.push_back(url);
   EXPECT_EQ(std::find_if(history_entries_.begin(), history_entries_.end(),
                          DownloadPersistentStoreInfoMatch(
-                             url, full_file_name, 1, DownloadItem::COMPLETE)),
+                             url_chain, full_file_name, 1,
+                             DownloadItem::COMPLETE)),
       history_entries_.end());
 
   EXPECT_TRUE(file_util::PathExists(full_file_name));
   EXPECT_FALSE(file_util::PathExists(dir));
   EXPECT_TRUE(file_util::ContentsEqual(
       test_dir_.Append(FilePath(kTestDir)).Append(FILE_PATH_LITERAL("a.htm")),
       full_file_name));
 }
 
 // This tests that a webpage with the title "test.exe" is saved as
@@ skipping 60 matching lines @@
   ASSERT_TRUE(WaitForSavePackageToFinish(browser(), &output_url));
   EXPECT_EQ(url, output_url);
   CheckDownloadHistory(url, full_file_name, -1, DownloadItem::COMPLETE);
 
   EXPECT_TRUE(file_util::PathExists(full_file_name));
   int64 actual_file_size = -1;
   EXPECT_TRUE(file_util::GetFileSize(full_file_name, &actual_file_size));
   EXPECT_LE(kFileSizeMin, actual_file_size);
 }