Move some download tests to content from chrome.

content/browser/download/download_content_browsertest.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[benjhayden, 2012/08/24 20:50:38]

How much of this file is new, and how much copy-pasted?
Do you want to try `git cp .../download_browsertest.cc
.../download_content_browsertest.cc` and then delete code from
download_content_browsertest.cc?

[Randy Smith (Not in Mondays), 2012/08/24 21:03:37]

Quite a bit was copy-pasted, but with a lot of mods (starting with
Browser->Shell, and continuing).  And just what I did had a lot of tugging on a
string about it.  I thought about trying to write some shared helper routines
(maybe inherit from a content class in chrome) but was a bit reluctant to tug on
a bigger string :-}.

My goals with the CL were a) Enable nuking of EnsureNoPendingDownloads() (next
CL), and b) provide an example of how to write browser tests at the content
layer in the downloads context.  I think this CL achieves those goals, at the
cost of some similar code.  I'm not sure how much I could reduce the duplicate
code without really rewriting things, but if you want I can take a swing at it.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file contains download browser tests that are known to be runnable
+// in a pure content context.  Over time tests should be migrated here.
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/scoped_temp_dir.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/download_item.h"
+#include "content/public/browser/download_manager.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/test/download_test_observer.h"
+#include "content/shell/shell.h"
+#include "content/shell/shell_download_manager_delegate.h"
+#include "content/test/content_browser_test.h"
+#include "content/test/content_browser_test_utils.h"
+#include "content/test/net/url_request_mock_http_job.h"
+#include "content/test/net/url_request_slow_download_job.h"
+#include "googleurl/src/gurl.h"
+
+namespace content {
+
+namespace {
+
+static DownloadManager* DownloadManagerForShell(Shell* shell) {
+  return BrowserContext::GetDownloadManager(
+      shell->web_contents()->GetBrowserContext());
+}
+
+}  // namespace
+
+class DownloadContentTest : public ContentBrowserTest {
+ protected:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
+
+    ShellDownloadManagerDelegate* delegate =
+    static_cast<ShellDownloadManagerDelegate*>(
+        shell()->web_contents()->GetBrowserContext()
+        ->GetDownloadManagerDelegate());
+    delegate->SetDownloadBehaviorForTesting(downloads_directory_.path());
+
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&URLRequestSlowDownloadJob::AddUrlHandler));
+    FilePath mock_base(GetTestFilePath("download", ""));
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&URLRequestMockHTTPJob::AddUrlHandler, mock_base));
+  }
+
+  // Create a DownloadTestObserverTerminal that will wait for the
+  // specified number of downloads to finish.
+  content::DownloadTestObserver* CreateWaiter(
+      Shell* shell, int num_downloads) {
+    DownloadManager* download_manager = DownloadManagerForShell(shell);
+    return new content::DownloadTestObserverTerminal(
+        download_manager, num_downloads,
+        content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
+  }
+
+  // Create a DownloadTestObserverInProgress that will wait for the
+  // specified number of downloads to start.
+  content::DownloadTestObserver* CreateInProgressWaiter(
+      Shell* shell, int num_downloads) {
+    DownloadManager* download_manager = DownloadManagerForShell(shell);
+    return new content::DownloadTestObserverInProgress(
+        download_manager, num_downloads);
+  }
+
+  bool EnsureNoPendingDownloads() {
+    bool result = true;
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&EnsureNoPendingDownloadJobsOnIO, &result));
+    MessageLoop::current()->Run();
+    return result && DownloadManager::EnsureNoPendingDownloadsForTesting();
+  }
+
+  void DownloadAndWait(Shell* shell, const GURL& url) {
+    scoped_ptr<content::DownloadTestObserver> observer(CreateWaiter(shell, 1));
+    NavigateToURL(shell, url);
+    observer->WaitForFinished();
+    EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+  }
+
+  // Checks that |path| is has |file_size| bytes, and matches the |value|
+  // string.
+  bool VerifyFile(const FilePath& path,
+                  const std::string& value,
+                  const int64 file_size) {
+    std::string file_contents;
+
+    bool read = file_util::ReadFileToString(path, &file_contents);
+    EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
+    if (!read)
+      return false;  // Couldn't read the file.
+
+    // Note: we don't handle really large files (more than size_t can hold)
+    // so we will fail in that case.
+    size_t expected_size = static_cast<size_t>(file_size);
+
+    // Check the size.
+    EXPECT_EQ(expected_size, file_contents.size());
+    if (expected_size != file_contents.size())
+      return false;
+
+    // Check the contents.
+    EXPECT_EQ(value, file_contents);
+    if (memcmp(file_contents.c_str(), value.c_str(), expected_size) != 0)
+      return false;
+
+    return true;
+  }
+
+ private:
+  static void EnsureNoPendingDownloadJobsOnIO(bool* result) {
+    if (URLRequestSlowDownloadJob::NumberOutstandingRequests())
+      *result = false;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, MessageLoop::QuitClosure());
+  }
+
+  // Location of the downloads directory for these tests
+  ScopedTempDir downloads_directory_;
+};
+
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadCancelled) {
+  // TODO(rdsmith): Fragile code warning!  The code below relies on the
+  // DownloadTestObserverInProgress only finishing when the new download
+  // has reached the state of being entered into the history and being
+  // user-visible (that's what's required for the Remove to be valid and
+  // for the download shelf to be visible).  By the pure semantics of
+  // DownloadTestObserverInProgress, that's not guaranteed; DownloadItems
+  // are created in the IN_PROGRESS state and made known to the DownloadManager
+  // immediately, so any ModelChanged event on the DownloadManager after
+  // navigation would allow the observer to return.  However, the only
+  // ModelChanged() event the code will currently fire is in
+  // OnCreateDownloadEntryComplete, at which point the download item will
+  // be in the state we need.
+  // The right way to fix this is to create finer grained states on the
+  // DownloadItem, and wait for the state that indicates the item has been
+  // entered in the history and made visible in the UI.
+
+  // Create a download, wait until it's started, and confirm
+  // we're in the expected state.
+  scoped_ptr<DownloadTestObserver> observer(CreateInProgressWaiter(shell(), 1));
+  NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
+  observer->WaitForFinished();
+
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForShell(shell())->SearchDownloads(string16(), &downloads);
+  ASSERT_EQ(1u, downloads.size());
+  ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
+
+  // Cancel the download and wait for download system quiesce.
+  downloads[0]->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
+  scoped_refptr<DownloadTestFlushObserver> flush_observer(
+      new DownloadTestFlushObserver(DownloadManagerForShell(shell())));
+  flush_observer->WaitForFlush();
+
+  // Get the important info from other threads and check it.
+  EXPECT_TRUE(EnsureNoPendingDownloads());
+}
+
+// Check that downloading multiple (in this case, 2) files does not result in
+// corrupted files.
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, MultiDownload) {
+  // Create a download, wait until it's started, and confirm
+  // we're in the expected state.
+  scoped_ptr<DownloadTestObserver> observer1(
+      CreateInProgressWaiter(shell(), 1));
+  NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
+  observer1->WaitForFinished();
+
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForShell(shell())->SearchDownloads(string16(), &downloads);
+  ASSERT_EQ(1u, downloads.size());
+  ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
+  DownloadItem* download1 = downloads[0];  // The only download.
+
+  // Start the second download and wait until it's done.
+  FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
+  GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
+  // Download the file and wait.
+  DownloadAndWait(shell(), url);
+
+  // Should now have 2 items on the manager.
+  downloads.clear();
+  DownloadManagerForShell(shell())->SearchDownloads(string16(), &downloads);
+  ASSERT_EQ(2u, downloads.size());
+  // We don't know the order of the downloads.
+  DownloadItem* download2 = downloads[(download1 == downloads[0]) ? 1 : 0];
+
+  ASSERT_EQ(DownloadItem::IN_PROGRESS, download1->GetState());
+  ASSERT_EQ(DownloadItem::COMPLETE, download2->GetState());
+
+  // Allow the first request to finish.
+  scoped_ptr<DownloadTestObserver> observer2(CreateWaiter(shell(), 1));
+  NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kFinishDownloadUrl));
+  observer2->WaitForFinished();  // Wait for the third request.
+  EXPECT_EQ(1u, observer2->NumDownloadsSeenInState(DownloadItem::COMPLETE));
+
+  // Get the important info from other threads and check it.
+  EXPECT_TRUE(EnsureNoPendingDownloads());
+
+  // The |DownloadItem|s should now be done and have the final file names.
+  // Verify that the files have the expected data and size.
+  // |file1| should be full of '*'s, and |file2| should be the same as the
+  // source file.
+  FilePath file1(download1->GetFullPath());
+  size_t file_size1 = URLRequestSlowDownloadJob::kFirstDownloadSize +
+                      URLRequestSlowDownloadJob::kSecondDownloadSize;
+  std::string expected_contents(file_size1, '*');
+  ASSERT_TRUE(VerifyFile(file1, expected_contents, file_size1));
+
+  FilePath file2(download2->GetFullPath());
+  ASSERT_TRUE(file_util::ContentsEqual(
+      file2, GetTestFilePath("download", "download-test1.lib")));
+}
+
+}  // namespace content