Make DownloadHistory observe manager, items

chrome/browser/extensions/api/downloads/downloads_api_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 <algorithm>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/download/download_file_icon_extractor.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_test_file_chooser_observer.h"
 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "chrome/browser/history/download_row.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
-#include "content/public/browser/download_persistent_store_info.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/test/download_test_observer.h"
 #include "content/test/net/url_request_slow_download_job.h"
 #include "net/base/data_url.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "webkit/blob/blob_data.h"
 #include "webkit/blob/blob_storage_controller.h"
 #include "webkit/blob/blob_url_request_job.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_url.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
-using content::DownloadPersistentStoreInfo;
 using content::URLRequestSlowDownloadJob;
 
 namespace events = extensions::event_names;
 
 namespace {
 
 // Comparator that orders download items by their ID. Can be used with
 // std::sort.
 struct DownloadIdComparator {
   bool operator() (DownloadItem* first, DownloadItem* second) {
@@ skipping 278 matching lines @@
 
   // Creates a set of history downloads based on the provided |history_info|
   // array. |count| is the number of elements in |history_info|. On success,
   // |items| will contain |count| DownloadItems in the order that they were
   // specified in |history_info|. Returns true on success and false otherwise.
   bool CreateHistoryDownloads(const HistoryDownloadInfo* history_info,
                               size_t count,
                               DownloadManager::DownloadVector* items) {
     DownloadIdComparator download_id_comparator;
     base::Time current = base::Time::Now();
-    std::vector<DownloadPersistentStoreInfo> entries;
-    entries.reserve(count);
+    items->clear();
+    GetOnRecordManager()->GetAllDownloads(items);
+    CHECK_EQ(0, static_cast<int>(items->size()));
     for (size_t i = 0; i < count; ++i) {
-      DownloadPersistentStoreInfo entry(
+      DownloadItem* item = GetOnRecordManager()->CreateDownloadItem(
           downloads_directory().Append(history_info[i].filename),
           GURL(), GURL(),    // URL, referrer
           current, current,  // start_time, end_time
           1, 1,              // received_bytes, total_bytes
           history_info[i].state,  // state
-          i + 1,                  // db_handle
           false);                 // opened
-      entries.push_back(entry);
+      items->push_back(item);
     }
-    GetOnRecordManager()->OnPersistentStoreQueryComplete(&entries);
-    GetOnRecordManager()->GetAllDownloads(items);
-    EXPECT_EQ(count, items->size());
-    if (count != items->size())
-      return false;
 
     // Order by ID so that they are in the order that we created them.
     std::sort(items->begin(), items->end(), download_id_comparator);
     // Set the danger type if necessary.
     for (size_t i = 0; i < count; ++i) {
       if (history_info[i].danger_type !=
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS) {
         EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT,
                   history_info[i].danger_type);
         items->at(i)->OnContentCheckCompleted(history_info[i].danger_type);
@@ skipping 188 matching lines @@
   void RunCallback() {
     callback_.Run(response_);
   }
 
   FilePath             expected_path_;
   IconLoader::IconSize expected_icon_size_;
   std::string          response_;
   IconURLCallback      callback_;
 };
 
+bool ItemNotInProgress(DownloadItem* item) {
+  return !item->IsInProgress();
+}
+
 // Cancels the underlying DownloadItem when the ScopedCancellingItem goes out of
 // scope. Like a scoped_ptr, but for DownloadItems.
 class ScopedCancellingItem {
  public:
   explicit ScopedCancellingItem(DownloadItem* item) : item_(item) {}
   ~ScopedCancellingItem() {
     item_->Cancel(true);
+    content::DownloadUpdatedObserver observer(
+        item_, base::Bind(&ItemNotInProgress));
+    observer.WaitForEvent();
   }
   DownloadItem* operator*() { return item_; }
   DownloadItem* operator->() { return item_; }
   DownloadItem* get() { return item_; }
  private:
   DownloadItem* item_;
   DISALLOW_COPY_AND_ASSIGN(ScopedCancellingItem);
 };
 
 // Cancels all the underlying DownloadItems when the ScopedItemVectorCanceller
 // goes out of scope. Generalization of ScopedCancellingItem to many
 // DownloadItems.
 class ScopedItemVectorCanceller {
  public:
   explicit ScopedItemVectorCanceller(DownloadManager::DownloadVector* items)
     : items_(items) {
   }
   ~ScopedItemVectorCanceller() {
     for (DownloadManager::DownloadVector::const_iterator item = items_->begin();
          item != items_->end(); ++item) {
       if ((*item)->IsInProgress())
         (*item)->Cancel(true);
+      content::DownloadUpdatedObserver observer(
+          (*item), base::Bind(&ItemNotInProgress));
+      observer.WaitForEvent();
     }
   }
 
  private:
   DownloadManager::DownloadVector* items_;
   DISALLOW_COPY_AND_ASSIGN(ScopedItemVectorCanceller);
 };
 
 class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
  public:
@@ skipping 265 matching lines @@
     const FilePath& expected_path,
     IconLoader::IconSize icon_size,
     const std::string& response) {
   scoped_refptr<DownloadsGetFileIconFunction> function(
       new DownloadsGetFileIconFunction());
   function->SetIconExtractorForTesting(new MockIconExtractorImpl(
       expected_path, icon_size, response));
   return function.release();
 }
 
-bool WaitForPersisted(DownloadItem* item) {
-  return item->IsPersisted();
-}
-
 // Test downloads.getFileIcon() on in-progress, finished, cancelled and deleted
 // download items.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_FileIcon_Active) {
   DownloadItem* download_item = CreateSlowTestDownload();
   ASSERT_TRUE(download_item);
+  ASSERT_FALSE(download_item->GetTargetFilePath().empty());
   std::string args32(base::StringPrintf("[%d, {\"size\": 32}]",
                      download_item->GetId()));
   std::string result_string;
 
   // Get the icon for the in-progress download.  This call should succeed even
   // if the file type isn't registered.
   // Test whether the correct path is being pased into the icon extractor.
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
       base::StringPrintf("[%d, {}]", download_item->GetId()), &result_string));
@@ skipping 16 matching lines @@
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
       args32, &result_string));
 
   // Check the path passed to the icon extractor post-completion.
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
       args32, &result_string));
 
   // Now create another download.
   download_item = CreateSlowTestDownload();
+  ASSERT_TRUE(download_item);
+  ASSERT_FALSE(download_item->GetTargetFilePath().empty());
   args32 = base::StringPrintf("[%d, {\"size\": 32}]", download_item->GetId());
-  ASSERT_TRUE(download_item);
-
-  // http://crbug.com/154995
-  content::DownloadUpdatedObserver persisted(
-      download_item, base::Bind(&WaitForPersisted));
-  persisted.WaitForEvent();
 
   // Cancel the download. As long as the download has a target path, we should
   // be able to query the file icon.
   download_item->Cancel(true);
+  ASSERT_FALSE(download_item->GetTargetFilePath().empty());
   // Let cleanup complete on the FILE thread.
   content::RunAllPendingInMessageLoop(BrowserThread::FILE);
   // Check the path passed to the icon extractor post-cancellation.
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
       args32,
       &result_string));
 
   // Simulate an error during icon load by invoking the mock with an empty
   // result string.
@@ skipping 1116 matching lines @@
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
                           GetFilename("on_record.txt.crdownload").c_str(),
                           GetFilename("on_record.txt").c_str())));
   std::string disk_data;
   EXPECT_TRUE(file_util::ReadFileToString(item->GetFullPath(), &disk_data));
   EXPECT_STREQ(kPayloadData, disk_data.c_str());
 }