A few minor changes to the chrome.downloads extension API

chrome/browser/extensions/api/downloads/downloads_api_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.
 
+// TODO occam move to _browser_test.cc
+
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 40 matching lines @@
 #include "webkit/common/blob/blob_data.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::URLRequestSlowDownloadJob;
 
 namespace events = extensions::event_names;
 
+namespace errors = download_extension_errors;
+
 namespace {
 
 // Comparator that orders download items by their ID. Can be used with
 // std::sort.
 struct DownloadIdComparator {
   bool operator() (DownloadItem* first, DownloadItem* second) {
     return first->GetId() < second->GetId();
   }
 };
 
@@ skipping 267 matching lines @@
       observer.EnableFileChooser(false);
     }
     current_browser_ = incognito_browser_;
   }
 
   bool WaitFor(const std::string& event_name, const std::string& json_args) {
     return events_listener_->WaitFor(
         current_browser()->profile(), event_name, json_args);
   }
 
-  bool WaitForInterruption(DownloadItem* item, int expected_error,
-                           const std::string& on_created_event) {
+  bool WaitForInterruption(
+      DownloadItem* item,
+      content::DownloadInterruptReason expected_error,
+      const std::string& on_created_event) {
     if (!WaitFor(events::kOnDownloadCreated, on_created_event))
       return false;
     // Now, onCreated is always fired before interruption.
     return WaitFor(events::kOnDownloadChanged,
         base::StringPrintf("[{\"id\": %d,"
-                            "  \"error\": {\"current\": %d},"
-                            "  \"state\": {"
-                            "    \"previous\": \"in_progress\","
-                            "    \"current\": \"interrupted\"}}]",
-                            item->GetId(),
-                            expected_error));
+                           "  \"error\": {\"current\": \"%s\"},"
+                           "  \"state\": {"
+                           "    \"previous\": \"in_progress\","
+                           "    \"current\": \"interrupted\"}}]",
+                           item->GetId(),
+                           content::InterruptReasonDebugString(
+                             expected_error).c_str()));
   }
 
   void ClearEvents() {
     events_listener_->ClearEvents();
   }
 
   std::string GetExtensionURL() {
     return extension_->url().spec();
   }
   std::string GetExtensionId() {
@@ skipping 527 matching lines @@
 
 bool ItemIsInterrupted(DownloadItem* item) {
   return item->GetState() == DownloadItem::INTERRUPTED;
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Open) {
   LoadExtension("downloads_split");
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kInvalidId,
                RunFunctionAndReturnError(
                    new DownloadsOpenFunction(),
                    "[-42]").c_str());
 
   DownloadItem* download_item = CreateSlowTestDownload();
   ASSERT_TRUE(download_item);
   EXPECT_FALSE(download_item->GetOpened());
   EXPECT_FALSE(download_item->GetOpenWhenComplete());
   ASSERT_TRUE(WaitFor(events::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
                          "  \"incognito\": false,"
                          "  \"mime\": \"application/octet-stream\","
                          "  \"paused\": false,"
                          "  \"url\": \"%s\"}]",
                          download_item->GetURL().spec().c_str())));
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kNotComplete,
                RunFunctionAndReturnError(
                    new DownloadsOpenFunction(),
                    DownloadItemIdAsArgList(download_item)).c_str());
 
   FinishPendingSlowDownloads();
   EXPECT_FALSE(download_item->GetOpened());
   EXPECT_TRUE(RunFunction(new DownloadsOpenFunction(),
                           DownloadItemIdAsArgList(download_item)));
   EXPECT_TRUE(download_item->GetOpened());
 }
@@ skipping 32 matching lines @@
   // And now cancel.
   EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(),
                           DownloadItemIdAsArgList(download_item)));
   EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState());
 
   // Cancel again.  Shouldn't have any effect.
   EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(),
                           DownloadItemIdAsArgList(download_item)));
   EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState());
 
-  // Calling paused on a non-active download yields kInvalidOperationError.
+  // Calling paused on a non-active download yields kInvalidId.
   std::string error = RunFunctionAndReturnError(
       new DownloadsPauseFunction(), DownloadItemIdAsArgList(download_item));
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
-               error.c_str());
+  EXPECT_STREQ(errors::kNotInProgress, error.c_str());
 
-  // Calling resume on a non-active download yields kInvalidOperationError
+  // Calling resume on a non-active download yields kInvalidId
   error = RunFunctionAndReturnError(
       new DownloadsResumeFunction(), DownloadItemIdAsArgList(download_item));
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
-               error.c_str());
+  EXPECT_STREQ(errors::kNotInProgress, error.c_str());
 
-  // Calling paused on a non-existent download yields kInvalidOperationError.
+  // Calling paused on a non-existent download yields kInvalidId.
   error = RunFunctionAndReturnError(
       new DownloadsPauseFunction(), "[-42]");
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
-               error.c_str());
+  EXPECT_STREQ(errors::kInvalidId, error.c_str());
 
-  // Calling resume on a non-existent download yields kInvalidOperationError
+  // Calling resume on a non-existent download yields kInvalidId
   error = RunFunctionAndReturnError(
       new DownloadsResumeFunction(), "[-42]");
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
-               error.c_str());
+  EXPECT_STREQ(errors::kInvalidId, error.c_str());
 
   int id = download_item->GetId();
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsEraseFunction(),
       base::StringPrintf("[{\"id\": %d}]", id)));
   DownloadManager::DownloadVector items;
   GetCurrentManager()->GetAllDownloads(&items);
   EXPECT_EQ(0UL, items.size());
   ASSERT_TRUE(result);
   download_item = NULL;
@@ skipping 75 matching lines @@
       args32,
       &result_string));
 
   // Simulate an error during icon load by invoking the mock with an empty
   // result string.
   std::string error = RunFunctionAndReturnError(
       MockedGetFileIconFunction(download_item->GetTargetFilePath(),
                                 IconLoader::NORMAL,
                                 std::string()),
       args32);
-  EXPECT_STREQ(download_extension_errors::kIconNotFoundError, error.c_str());
+  EXPECT_STREQ(errors::kIconNotFound, error.c_str());
 
-  // Once the download item is deleted, we should return kInvalidOperationError.
+  // Once the download item is deleted, we should return kInvalidId.
   int id = download_item->GetId();
   download_item->Remove();
   download_item = NULL;
   EXPECT_EQ(static_cast<DownloadItem*>(NULL),
             GetCurrentManager()->GetDownload(id));
   error = RunFunctionAndReturnError(new DownloadsGetFileIconFunction(), args32);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kInvalidId,
                error.c_str());
 }
 
 // Test that we can acquire file icons for history downloads regardless of
 // whether they exist or not.  If the file doesn't exist we should receive a
 // generic icon from the OS/toolkit that may or may not be specific to the file
 // type.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_FileIcon_History) {
   const HistoryDownloadInfo kHistoryInfo[] = {
@@ skipping 20 matching lines @@
        ++iter) {
     std::string result_string;
     // Use a MockIconExtractorImpl to test if the correct path is being passed
     // into the DownloadFileIconExtractor.
     EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
             (*iter)->GetTargetFilePath(), IconLoader::NORMAL, "hello"),
         base::StringPrintf("[%d, {\"size\": 32}]", (*iter)->GetId()),
         &result_string));
     EXPECT_STREQ("hello", result_string.c_str());
   }
-
-  // The temporary files should be cleaned up when the base::ScopedTempDir is removed.
 }
 
 // Test passing the empty query to search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_SearchEmptyQuery) {
   ScopedCancellingItem item(CreateSlowTestDownload());
   ASSERT_TRUE(item.get());
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{}]"));
@@ skipping 76 matching lines @@
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS },
     { FILE_PATH_LITERAL("baz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }
   };
   DownloadManager::DownloadVector items;
   ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo),
                                      &items));
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsSearchFunction(), "[{\"orderBy\": \"filename\"}]"));
+      new DownloadsSearchFunction(), "[{\"orderBy\": [\"filename\"]}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(2UL, result_list->GetSize());
   base::DictionaryValue* item0_value = NULL;
   base::DictionaryValue* item1_value = NULL;
   ASSERT_TRUE(result_list->GetDictionary(0, &item0_value));
   ASSERT_TRUE(result_list->GetDictionary(1, &item1_value));
   std::string item0_name, item1_name;
   ASSERT_TRUE(item0_value->GetString("filename", &item0_name));
@@ skipping 12 matching lines @@
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS },
     { FILE_PATH_LITERAL("baz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }
   };
   DownloadManager::DownloadVector items;
   ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo),
                                      &items));
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsSearchFunction(), "[{\"orderBy\": \"\"}]"));
+      new DownloadsSearchFunction(), "[{\"orderBy\": []}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(2UL, result_list->GetSize());
   base::DictionaryValue* item0_value = NULL;
   base::DictionaryValue* item1_value = NULL;
   ASSERT_TRUE(result_list->GetDictionary(0, &item0_value));
   ASSERT_TRUE(result_list->GetDictionary(1, &item1_value));
   std::string item0_name, item1_name;
   ASSERT_TRUE(item0_value->GetString("filename", &item0_name));
@@ skipping 56 matching lines @@
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(1UL, result_list->GetSize());
 }
 
 // Test invalid search parameters.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchInvalid) {
   std::string error = RunFunctionAndReturnError(
       new DownloadsSearchFunction(), "[{\"filenameRegex\": \"(\"}]");
-  EXPECT_STREQ(download_extension_errors::kInvalidFilterError,
+  EXPECT_STREQ(errors::kInvalidFilter,
       error.c_str());
   error = RunFunctionAndReturnError(
-      new DownloadsSearchFunction(), "[{\"orderBy\": \"goat\"}]");
-  EXPECT_STREQ(download_extension_errors::kInvalidOrderByError,
+      new DownloadsSearchFunction(), "[{\"orderBy\": [\"goat\"]}]");
+  EXPECT_STREQ(errors::kInvalidOrderBy,
       error.c_str());
   error = RunFunctionAndReturnError(
       new DownloadsSearchFunction(), "[{\"limit\": -1}]");
-  EXPECT_STREQ(download_extension_errors::kInvalidQueryLimit,
+  EXPECT_STREQ(errors::kInvalidQueryLimit,
       error.c_str());
 }
 
 // Test searching using multiple conditions through multiple downloads.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchPlural) {
   const HistoryDownloadInfo kHistoryInfo[] = {
     { FILE_PATH_LITERAL("aaa"),
       DownloadItem::CANCELLED,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS },
     { FILE_PATH_LITERAL("zzz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT },
     { FILE_PATH_LITERAL("baz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT },
   };
   DownloadManager::DownloadVector items;
   ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo),
                                      &items));
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{"
       "\"state\": \"complete\", "
       "\"danger\": \"content\", "
-      "\"orderBy\": \"filename\", "
+      "\"orderBy\": [\"filename\"], "
       "\"limit\": 1}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(1UL, result_list->GetSize());
   base::DictionaryValue* item_value = NULL;
   ASSERT_TRUE(result_list->GetDictionary(0, &item_value));
   base::FilePath::StringType item_name;
   ASSERT_TRUE(item_value->GetString("filename", &item_name));
   ASSERT_EQ(items[2]->GetTargetFilePath().value(), item_name);
@@ skipping 59 matching lines @@
   ASSERT_EQ(1UL, result_list->GetSize());
   ASSERT_TRUE(result_list->GetDictionary(0, &result_dict));
   ASSERT_TRUE(result_dict->GetString("filename", &filename));
   EXPECT_TRUE(on_item->GetTargetFilePath() == base::FilePath(filename));
   ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito));
   EXPECT_FALSE(is_incognito);
 
   // Pausing/Resuming the off-record item while on the record should return an
   // error. Cancelling "non-existent" downloads is not an error.
   error = RunFunctionAndReturnError(new DownloadsPauseFunction(), off_item_arg);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kInvalidId,
                error.c_str());
   error = RunFunctionAndReturnError(new DownloadsResumeFunction(),
                                     off_item_arg);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kInvalidId,
                error.c_str());
   error = RunFunctionAndReturnError(
       new DownloadsGetFileIconFunction(),
       base::StringPrintf("[%d, {}]", off_item->GetId()));
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kInvalidId,
                error.c_str());
 
   GoOffTheRecord();
 
   // Do the FileIcon test for both the on- and off-items while off the record.
   // NOTE(benjhayden): This does not include the FileIcon test from history,
   // just active downloads. This shouldn't be a problem.
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           on_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
       base::StringPrintf("[%d, {}]", on_item->GetId()), &result_string));
@@ skipping 11 matching lines @@
   EXPECT_FALSE(on_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), on_item_arg));
   EXPECT_FALSE(on_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), on_item_arg));
   EXPECT_TRUE(on_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), on_item_arg));
   EXPECT_EQ(DownloadItem::CANCELLED, on_item->GetState());
   EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), on_item_arg));
   EXPECT_EQ(DownloadItem::CANCELLED, on_item->GetState());
   error = RunFunctionAndReturnError(new DownloadsPauseFunction(), on_item_arg);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kNotInProgress,
                error.c_str());
   error = RunFunctionAndReturnError(new DownloadsResumeFunction(), on_item_arg);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kNotInProgress,
                error.c_str());
   EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg));
   EXPECT_TRUE(off_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg));
   EXPECT_TRUE(off_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), off_item_arg));
   EXPECT_FALSE(off_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), off_item_arg));
   EXPECT_FALSE(off_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg));
   EXPECT_TRUE(off_item->IsPaused());
   EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), off_item_arg));
   EXPECT_EQ(DownloadItem::CANCELLED, off_item->GetState());
   EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), off_item_arg));
   EXPECT_EQ(DownloadItem::CANCELLED, off_item->GetState());
   error = RunFunctionAndReturnError(new DownloadsPauseFunction(),
                                     off_item_arg);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kNotInProgress,
                error.c_str());
   error = RunFunctionAndReturnError(new DownloadsResumeFunction(),
                                     off_item_arg);
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
+  EXPECT_STREQ(errors::kNotInProgress,
                error.c_str());
 }
 
 // Test that we can start a download and that the correct sequence of events is
 // fired for it.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_Basic) {
   LoadExtension("downloads_split");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(test_server()->Start());
@@ skipping 118 matching lines @@
     "sEc-",
     "pRoxY-probably-not-evil",
     "sEc-probably-not-evil",
     "oRiGiN",
     "Access-Control-Request-Headers",
     "Access-Control-Request-Method",
   };
 
   for (size_t index = 0; index < arraysize(kUnsafeHeaders); ++index) {
     std::string download_url = test_server()->GetURL("slow?0").spec();
-    EXPECT_STREQ(download_extension_errors::kGenericError,
+    EXPECT_STREQ(errors::kInvalidHeader,
                   RunFunctionAndReturnError(new DownloadsDownloadFunction(),
                                             base::StringPrintf(
         "[{\"url\": \"%s\","
         "  \"filename\": \"unsafe-header-%d.txt\","
         "  \"headers\": [{"
         "    \"name\": \"%s\","
         "    \"value\": \"unsafe\"}]}]",
         download_url.c_str(),
         static_cast<int>(index),
         kUnsafeHeaders[index])).c_str());
   }
 }
 
-// Test that subdirectories (slashes) are disallowed in filenames.
-// TODO(benjhayden) Update this when subdirectories are supported.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_Subdirectory) {
   LoadExtension("downloads_split");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(test_server()->Start());
   std::string download_url = test_server()->GetURL("slow?0").spec();
   GoOnTheRecord();
 
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError,
-                RunFunctionAndReturnError(new DownloadsDownloadFunction(),
-                                          base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"sub/dir/ect/ory.txt\"}]",
-      download_url.c_str())).c_str());
+  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
+      new DownloadsDownloadFunction(), base::StringPrintf(
+          "[{\"url\": \"%s\","
+          "  \"filename\": \"sub/dir/ect/ory.txt\"}]",
+          download_url.c_str())));
+  ASSERT_TRUE(result.get());
+  int result_id = -1;
+  ASSERT_TRUE(result->GetAsInteger(&result_id));
+  DownloadItem* item = GetCurrentManager()->GetDownload(result_id);
+  ASSERT_TRUE(item);
+  ScopedCancellingItem canceller(item);
+  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
+
+  ASSERT_TRUE(WaitFor(events::kOnDownloadCreated,
+      base::StringPrintf("[{\"danger\": \"safe\","
+                         "  \"incognito\": false,"
+                         "  \"mime\": \"text/plain\","
+                         "  \"paused\": false,"
+                         "  \"url\": \"%s\"}]",
+                         download_url.c_str())));
+  ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
+      base::StringPrintf("[{\"id\": %d,"
+                         "  \"filename\": {"
+                         "    \"previous\": \"\","
+                         "    \"current\": \"%s\"}}]",
+                         result_id,
+                         GetFilename("sub/dir/ect/ory.txt").c_str())));
+  ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
+      base::StringPrintf("[{\"id\": %d,"
+                         "  \"state\": {"
+                         "    \"previous\": \"in_progress\","
+                         "    \"current\": \"complete\"}}]",
+                         result_id)));
 }
 
 // Test that invalid filenames are disallowed.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_InvalidFilename) {
   LoadExtension("downloads_split");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(test_server()->Start());
   std::string download_url = test_server()->GetURL("slow?0").spec();
   GoOnTheRecord();
 
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError,
+  EXPECT_STREQ(errors::kInvalidFilename,
                 RunFunctionAndReturnError(new DownloadsDownloadFunction(),
                                           base::StringPrintf(
       "[{\"url\": \"%s\","
       "  \"filename\": \"../../../../../etc/passwd\"}]",
       download_url.c_str())).c_str());
 }
 
 // Test that downloading invalid URLs immediately returns kInvalidURLError.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_InvalidURLs) {
   LoadExtension("downloads_split");
   GoOnTheRecord();
 
   static const char* kInvalidURLs[] = {
     "foo bar",
     "../hello",
     "/hello",
-    "google.com/",
     "http://",
     "#frag",
     "foo/bar.html#frag",
+    "google.com/",
+  };
+
+  for (size_t index = 0; index < arraysize(kInvalidURLs); ++index) {
+    EXPECT_STREQ(errors::kInvalidURL,
+                  RunFunctionAndReturnError(new DownloadsDownloadFunction(),
+                                            base::StringPrintf(
+        "[{\"url\": \"%s\"}]", kInvalidURLs[index])).c_str())
+      << kInvalidURLs[index];
+  }
+
+  static const char* kNotPermittedURLs[] = {
     "javascript:document.write(\\\"hello\\\");",
     "javascript:return false;",
     "ftp://example.com/example.txt",
   };
 
-  for (size_t index = 0; index < arraysize(kInvalidURLs); ++index) {
-    EXPECT_STREQ(download_extension_errors::kInvalidURLError,
+  for (size_t index = 0; index < arraysize(kNotPermittedURLs); ++index) {
+    EXPECT_STREQ(errors::kNotPermittedURL,
                   RunFunctionAndReturnError(new DownloadsDownloadFunction(),
                                             base::StringPrintf(
-        "[{\"url\": \"%s\"}]", kInvalidURLs[index])).c_str());
+        "[{\"url\": \"%s\"}]", kNotPermittedURLs[index])).c_str())
+      << kNotPermittedURLs[index];
   }
 }
 
 // TODO(benjhayden): Set up a test ftp server, add ftp://localhost* to
 // permissions, test downloading from ftp.
 
 // Valid URLs plus fragments are still valid URLs.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_URLFragment) {
   LoadExtension("downloads_split");
@@ skipping 146 matching lines @@
       "  \"filename\": \"auth-basic-fail.txt\"}]",
       download_url.c_str())));
   ASSERT_TRUE(result.get());
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetDownload(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
-  ASSERT_TRUE(WaitForInterruption(item, 30, base::StringPrintf(
-      "[{\"danger\": \"safe\","
-      "  \"incognito\": false,"
-      "  \"mime\": \"text/html\","
-      "  \"paused\": false,"
-      "  \"url\": \"%s\"}]",
-      download_url.c_str())));
+  ASSERT_TRUE(WaitForInterruption(
+      item,
+      content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
+      base::StringPrintf("[{\"danger\": \"safe\","
+                         "  \"incognito\": false,"
+                         "  \"mime\": \"text/html\","
+                         "  \"paused\": false,"
+                         "  \"url\": \"%s\"}]",
+                         download_url.c_str())));
 }
 
 // Test that DownloadsDownloadFunction propagates |headers| to the URLRequest.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_Headers) {
   LoadExtension("downloads_split");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(test_server()->Start());
   std::string download_url = test_server()->GetURL("files/downloads/"
       "a_zip_file.zip?expected_headers=Foo:bar&expected_headers=Qx:yo").spec();
@@ skipping 56 matching lines @@
       "  \"filename\": \"headers-fail.txt\"}]",
       download_url.c_str())));
   ASSERT_TRUE(result.get());
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetDownload(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
-  ASSERT_TRUE(WaitForInterruption(item, 33, base::StringPrintf(
-      "[{\"danger\": \"safe\","
-      "  \"incognito\": false,"
-      "  \"bytesReceived\": 0,"
-      "  \"mime\": \"\","
-      "  \"paused\": false,"
-      "  \"url\": \"%s\"}]",
-      download_url.c_str())));
+  ASSERT_TRUE(WaitForInterruption(
+      item,
+      content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
+      base::StringPrintf("[{\"danger\": \"safe\","
+                         "  \"incognito\": false,"
+                         "  \"bytesReceived\": 0,"
+                         "  \"mime\": \"\","
+                         "  \"paused\": false,"
+                         "  \"url\": \"%s\"}]",
+                         download_url.c_str())));
 }
 
 // Test that DownloadsDownloadFunction propagates the Authorization header
 // correctly.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_AuthBasic) {
   LoadExtension("downloads_split");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(test_server()->Start());
   std::string download_url = test_server()->GetURL("auth-basic").spec();
@@ skipping 98 matching lines @@
       "  \"filename\": \"post-get.txt\"}]",
       download_url.c_str())));
   ASSERT_TRUE(result.get());
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetDownload(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
-  ASSERT_TRUE(WaitForInterruption(item, 33, base::StringPrintf(
-      "[{\"danger\": \"safe\","
-      "  \"incognito\": false,"
-      "  \"mime\": \"\","
-      "  \"paused\": false,"
-      "  \"id\": %d,"
-      "  \"url\": \"%s\"}]",
-      result_id,
-      download_url.c_str())));
+  ASSERT_TRUE(WaitForInterruption(
+      item,
+      content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
+      base::StringPrintf("[{\"danger\": \"safe\","
+                         "  \"incognito\": false,"
+                         "  \"mime\": \"\","
+                         "  \"paused\": false,"
+                         "  \"id\": %d,"
+                         "  \"url\": \"%s\"}]",
+                         result_id,
+                         download_url.c_str())));
 }
 
 // Test that downloadPostSuccess would fail if the resource requires the POST
 // method, and chrome fails to propagate the |body| parameter back to the
 // server. This tests both that testserver.py does not succeed when it should
 // fail, and this tests how the downloads extension api exposes the failure to
 // extensions.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_Post_NoBody) {
   LoadExtension("downloads_split");
@@ skipping 10 matching lines @@
       "  \"filename\": \"post-nobody.txt\"}]",
       download_url.c_str())));
   ASSERT_TRUE(result.get());
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetDownload(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
-  ASSERT_TRUE(WaitForInterruption(item, 33, base::StringPrintf(
-      "[{\"danger\": \"safe\","
-      "  \"incognito\": false,"
-      "  \"mime\": \"\","
-      "  \"paused\": false,"
-      "  \"id\": %d,"
-      "  \"url\": \"%s\"}]",
-      result_id,
-      download_url.c_str())));
+  ASSERT_TRUE(WaitForInterruption(
+      item,
+      content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
+      base::StringPrintf("[{\"danger\": \"safe\","
+                         "  \"incognito\": false,"
+                         "  \"mime\": \"\","
+                         "  \"paused\": false,"
+                         "  \"id\": %d,"
+                         "  \"url\": \"%s\"}]",
+                         result_id,
+                         download_url.c_str())));
 }
 
 // Test that cancel()ing an in-progress download causes its state to transition
 // to interrupted, and test that that state transition is detectable by an
 // onChanged event listener.  TODO(benjhayden): Test other sources of
 // interruptions such as server death.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_Cancel) {
   LoadExtension("downloads_split");
   ASSERT_TRUE(StartEmbeddedTestServer());
@@ skipping 18 matching lines @@
                           "  \"incognito\": false,"
                           "  \"mime\": \"application/octet-stream\","
                           "  \"paused\": false,"
                           "  \"id\": %d,"
                           "  \"url\": \"%s\"}]",
                           result_id,
                           download_url.c_str())));
   item->Cancel(true);
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
-                          "  \"error\": {\"current\": 40},"
+                          "  \"error\": {\"current\":\"USER_CANCELED\"},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"interrupted\"}}]",
                           result_id)));
 }
 
 // Test downloading filesystem: URLs.
 // NOTE: chrome disallows creating HTML5 FileSystem Files in incognito.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_FileSystemURL) {
@@ skipping 163 matching lines @@
       result_id,
       base::FilePath(FILE_PATH_LITERAL("overridden.swf")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
   EXPECT_EQ("", error);
 
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"danger\": {"
                          "    \"previous\":\"safe\","
-                         "    \"current\":\"file\"},"
-                         "  \"dangerAccepted\": {"
-                         "    \"current\":false}}]",
+                         "    \"current\":\"file\"}}]",
                          result_id)));
 
   item->ValidateDangerousDownload();
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
-                         "  \"dangerAccepted\": {"
-                         "    \"previous\":false,"
-                         "    \"current\":true}}]",
+                         "  \"danger\": {"
+                         "    \"previous\":\"file\","
+                         "    \"current\":\"accepted\"}}]",
                          result_id)));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id)));
   EXPECT_EQ(downloads_directory().AppendASCII("overridden.swf"),
             item->GetTargetFilePath());
 }
@@ skipping 40 matching lines @@
   // Respond to the onDeterminingFilename.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL("sneaky/../../sneaky.txt")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"\","
                           "    \"current\": \"%s\"}}]",
                           result_id,
                           GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"state\": {"
@@ skipping 44 matching lines @@
   // Respond to the onDeterminingFilename.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL("<")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf(
       "[{\"id\": %d,"
       "  \"filename\": {"
       "    \"previous\": \"\","
       "    \"current\": \"%s\"}}]",
       result_id,
       GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf(
       "[{\"id\": %d,"
       "  \"state\": {"
@@ skipping 45 matching lines @@
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL(
           "My Computer.{20D04FE0-3AEA-1069-A2D8-08002B30309D}/foo")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf(
       "[{\"id\": %d,"
       "  \"filename\": {"
       "    \"previous\": \"\","
       "    \"current\": \"%s\"}}]",
       result_id,
       GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf(
       "[{\"id\": %d,"
       "  \"state\": {"
@@ skipping 44 matching lines @@
   // Respond to the onDeterminingFilename.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL("con.foo")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf(
       "[{\"id\": %d,"
       "  \"filename\": {"
       "    \"previous\": \"\","
       "    \"current\": \"%s\"}}]",
       result_id,
       GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf(
       "[{\"id\": %d,"
       "  \"state\": {"
@@ skipping 44 matching lines @@
   // Respond to the onDeterminingFilename.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL(".")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"filename\": {"
                          "    \"previous\": \"\","
                          "    \"current\": \"%s\"}}]",
                          result_id,
                          GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"state\": {"
@@ skipping 44 matching lines @@
   // Respond to the onDeterminingFilename.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL("..")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"filename\": {"
                          "    \"previous\": \"\","
                          "    \"current\": \"%s\"}}]",
                          result_id,
                          GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"state\": {"
@@ skipping 44 matching lines @@
   // Respond to the onDeterminingFilename. Absolute paths should be rejected.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       downloads_directory().Append(FILE_PATH_LITERAL("sneaky.txt")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
 
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"\","
                           "    \"current\": \"%s\"}}]",
                           result_id,
                           GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
@@ skipping 45 matching lines @@
   // Respond to the onDeterminingFilename. Empty basenames should be rejected.
   std::string error;
   ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       result_id,
       base::FilePath(FILE_PATH_LITERAL("foo/")),
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY,
       &error));
-  EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str());
+  EXPECT_STREQ(errors::kInvalidFilename, error.c_str());
 
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"filename\": {"
                          "    \"previous\": \"\","
                          "    \"current\": \"%s\"}}]",
                          result_id,
                          GetFilename("slow.txt").c_str())));
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
@@ skipping 539 matching lines @@
                          "    \"previous\": \"\","
                          "    \"current\": \"%s\"}}]",
                          item->GetId(),
                          GetFilename("42.txt").c_str())));
 
   content::DownloadUpdatedObserver interrupted(item, base::Bind(
       ItemIsInterrupted));
   ASSERT_TRUE(interrupted.WaitForEvent());
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
-                         "  \"error\":{\"current\":20},"
+                         "  \"error\":{\"current\":\"NETWORK_FAILED\"},"
                          "  \"state\":{"
                          "    \"previous\":\"in_progress\","
                          "    \"current\":\"interrupted\"}}]",
                          item->GetId())));
 
   ClearEvents();
   // Downloads that are restarted on resumption trigger another download target
   // determination.
   RemoveFilenameDeterminer(host);
   item->Resume();
 
   // Errors caught before filename determination is complete are delayed until
   // after filename determination so that, on resumption, filename determination
   // does not need to be re-done. So, there will not be a second
   // onDeterminingFilename event.
 
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
-                         "  \"error\":{\"previous\":20},"
+                         "  \"error\":{\"previous\":\"NETWORK_FAILED\"},"
                          "  \"state\":{"
                          "    \"previous\":\"interrupted\","
                          "    \"current\":\"in_progress\"}}]",
                          item->GetId())));
 
   ClearEvents();
   FinishPendingSlowDownloads();
 
   // The download should complete successfully.
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
@@ skipping 15 matching lines @@
   DownloadsApiTest() {}
   virtual ~DownloadsApiTest() {}
  private:
   DISALLOW_COPY_AND_ASSIGN(DownloadsApiTest);
 };
 
 
 IN_PROC_BROWSER_TEST_F(DownloadsApiTest, DownloadsApiTest) {
   ASSERT_TRUE(RunExtensionTest("downloads")) << message_;
 }