Added read-only file error test.

chrome/browser/download/download_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/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
@@ skipping 232 matching lines @@
     DOWNLOAD_DIRECT
   };
 
   // Information passed in to |DownloadFileCheckErrors()|.
   struct DownloadInfo {
     const char* url_name;  // URL for the download.
     DownloadMethod download_method;  // Navigation or Direct.
     // Download interrupt reason (NONE is OK).
     content::DownloadInterruptReason reason;
     bool show_download_item;  // True if the download item appears on the shelf.
+    bool should_redirect_to_documents;  // True if we save it in "My Documents".
   };
 
   DownloadTest() {
     EnableDOMAutomation();
   }
 
   void SetUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
@@ skipping 371 matching lines @@
 
     // Check the contents.
     EXPECT_EQ(value, file_contents);
     if (memcmp(file_contents.c_str(), value.c_str(), expected_size) != 0)
       return false;
 
     return true;
   }
 
   // Attempts to download a file, based on information in |download_info|.
+  // If a Select File dialog opens, will automatically choose the default.
   void DownloadFileCheckErrors(const DownloadInfo& download_info) {
     ASSERT_TRUE(test_server()->Start());
     std::vector<DownloadItem*> download_items;
     GetDownloads(browser(), &download_items);
     ASSERT_TRUE(download_items.empty());
 
     NullSelectFile(browser());
 
     std::string server_path = "files/downloads/";
     server_path += download_info.url_name;
     GURL url = test_server()->GetURL(server_path);
     ASSERT_TRUE(url.is_valid());
 
+    NullSelectFile(browser());  // Needed for read-only tests.
+
     DownloadManager* download_manager = DownloadManagerForBrowser(browser());
     scoped_ptr<DownloadTestObserver> observer(
         new DownloadTestObserverTerminal(
             download_manager,
             1,
             false,  // Don't bail on select file.
             DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
 
     if (download_info.download_method == DOWNLOAD_DIRECT) {
       // Go directly to download.
@@ skipping 24 matching lines @@
         EXPECT_EQ(invalid_id, creation_observer->download_id().local());
       }
     } else {
       // Navigate to URL normally, wait until done.
       ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(),
                                                                 url,
                                                                 1);
     }
 
     if (download_info.show_download_item) {
       observer->WaitForFinished();

[Randy Smith (Not in Mondays), 2012/03/12 17:51:16]

Part of me's a little bothered that we're creating an object that in some
contexts never gets used.  If there's a clean way of avoiding creating the
observer if you're not going to wait on it, you might want to think about doing
it.  Up to you, though.

       DownloadItem::DownloadState final_state =
           (download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
               DownloadItem::COMPLETE :
               DownloadItem::INTERRUPTED;
       EXPECT_EQ(1u, observer->NumDownloadsSeenInState(final_state));
     }
 
     // Validate that the correct file was downloaded.
     download_items.clear();
     GetDownloads(browser(), &download_items);
     size_t item_count = download_info.show_download_item ? 1 : 0;
     ASSERT_EQ(item_count, download_items.size());
 
     if (download_info.show_download_item) {
       DownloadItem* item = download_items[0];
       ASSERT_EQ(url, item->GetOriginalUrl());
 
       ASSERT_EQ(download_info.reason, item->GetLastReason());
+
+      if (item->GetState() == content::DownloadItem::COMPLETE) {
+        // Clean up the file, in case it ended up in the My Documents folder.
+        FilePath destination_folder = GetDownloadDirectory(browser());
+        FilePath my_downloaded_file = item->GetTargetFilePath();
+        EXPECT_TRUE(file_util::PathExists(my_downloaded_file));
+        EXPECT_TRUE(file_util::Delete(my_downloaded_file, false));
+
+        EXPECT_EQ(download_info.should_redirect_to_documents ?
+                      std::string::npos :
+                      0u,
+                  my_downloaded_file.value().find(destination_folder.value()));
+        if (download_info.should_redirect_to_documents) {
+          // If it's not where we asked it to be, it should be in the
+          // My Documents folder.
+          FilePath my_docs_folder;
+          EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DOCUMENTS,
+                                       &my_docs_folder));
+          EXPECT_EQ(0u,
+                    my_downloaded_file.value().find(my_docs_folder.value()));
+        }
+      }
     }
   }
 
+  // Attempts to download a file to a read-only folder, based on information
+  // in |download_info|.
+  void DownloadFileToReadonlyFolder(const DownloadInfo& download_info) {
+    ASSERT_TRUE(InitialSetup(false));  // Creates temporary download folder.
+
+    // Make the test folder unwritable.
+    FilePath destination_folder = GetDownloadDirectory(browser());
+    DVLOG(1) << " " << __FUNCTION__ << "()"
+             << " folder = '" << destination_folder.value() << "'";
+    file_util::PermissionRestorer permission_restorer(destination_folder);
+    EXPECT_TRUE(file_util::MakeFileUnwritable(destination_folder));
+
+    DownloadFileCheckErrors(download_info);
+  }
+
  private:
   // Location of the test data.
   FilePath test_dir_;
 
   // Location of the downloads directory for these tests
   ScopedTempDir downloads_directory_;
 };
 
 // NOTES:
 //
@@ skipping 1272 matching lines @@
   ASSERT_EQ(2u, download_items.size());
   ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
   ASSERT_EQ(jpeg_url, download_items[1]->GetOriginalUrl());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadNavigate) {
   DownloadInfo download_info = {
     "a_zip_file.zip",
     DOWNLOAD_NAVIGATE,
     content::DOWNLOAD_INTERRUPT_REASON_NONE,
-    true
+    true,
+    false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadDirect) {
   DownloadInfo download_info = {
     "a_zip_file.zip",
     DOWNLOAD_DIRECT,
     content::DOWNLOAD_INTERRUPT_REASON_NONE,
-    true
+    true,
+    false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadError404Direct) {
   DownloadInfo download_info = {
     "there_IS_no_spoon.zip",
     DOWNLOAD_DIRECT,
     content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
-    true
+    true,
+    false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadError404Navigate) {
   DownloadInfo download_info = {
     "there_IS_no_spoon.zip",
     DOWNLOAD_NAVIGATE,
     content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
+    false,
     false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadError400Direct) {
   DownloadInfo download_info = {
     "zip_file_not_found.zip",
     DOWNLOAD_DIRECT,
     content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
-    true
+    true,
+    false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadError400Navigate) {
   DownloadInfo download_info = {
     "zip_file_not_found.zip",
     DOWNLOAD_NAVIGATE,
     content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
+    false,
     false
   };
 
   // Do initial setup.
   ASSERT_TRUE(InitialSetup(false));
   DownloadFileCheckErrors(download_info);
 }
+
+IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorReadonlyFolderDirect) {
+  DownloadInfo download_info = {
+    "a_zip_file.zip",
+    DOWNLOAD_DIRECT,
+    // This passes because we switch to the My Documents folder.
+    content::DOWNLOAD_INTERRUPT_REASON_NONE,
+    true,
+    true
+  };
+
+  DownloadFileToReadonlyFolder(download_info);
+}
+
+IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorReadonlyFolderNavigate) {
+  DownloadInfo download_info = {
+    "a_zip_file.zip",
+    DOWNLOAD_NAVIGATE,
+    // This passes because we switch to the My Documents folder.
+    content::DOWNLOAD_INTERRUPT_REASON_NONE,
+    true,
+    true
+  };
+
+  DownloadFileToReadonlyFolder(download_info);
+}