A few minor changes to the chrome.downloads extension API

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/message_loop.h"
@@ skipping 164 matching lines @@
                        const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT:
         {
           DownloadsNotificationSource* dns =
               content::Source<DownloadsNotificationSource>(source).ptr();
           Event* new_event = new Event(
               dns->profile,
               dns->event_name,
               *content::Details<std::string>(details).ptr(), base::Time::Now());
+          LOG(INFO) << "occam caught " << new_event->Debug();

[asanka, 2013/07/16 19:57:52]

to be removed?

[benjhayden, 2013/07/19 15:53:55]

Done.

           events_.push_back(new_event);
           if (waiting_ &&
               waiting_for_.get() &&
               new_event->Satisfies(*waiting_for_)) {
             waiting_ = false;
             base::MessageLoopForUI::current()->Quit();
           }
           break;
         }
       default:
         NOTREACHED();
     }
   }
 
   bool WaitFor(Profile* profile,
                const std::string& event_name,
                const std::string& json_args) {
     waiting_for_.reset(new Event(profile, event_name, json_args, base::Time()));
     for (std::deque<Event*>::const_iterator iter = events_.begin();
          iter != events_.end(); ++iter) {
       if ((*iter)->Satisfies(*waiting_for_.get())) {
         return true;
       }
     }
+    LOG(INFO) << "occam waiting " << waiting_for_->Debug();
     waiting_ = true;
     content::RunMessageLoop();
     bool success = !waiting_;
     if (waiting_) {
       // Print the events that were caught since the last WaitFor() call to help
       // find the erroneous event.
       // TODO(benjhayden) Fuzzy-match and highlight the erroneous event.
       for (std::deque<Event*>::const_iterator iter = events_.begin();
           iter != events_.end(); ++iter) {
         if ((*iter)->caught() > last_wait_) {
@@ skipping 123 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 860 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 59 matching lines @@
 }
 
 // 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,
       error.c_str());
   error = RunFunctionAndReturnError(
-      new DownloadsSearchFunction(), "[{\"orderBy\": \"goat\"}]");
+      new DownloadsSearchFunction(), "[{\"orderBy\": [\"goat\"]}]");
   EXPECT_STREQ(download_extension_errors::kInvalidOrderByError,
       error.c_str());
   error = RunFunctionAndReturnError(
       new DownloadsSearchFunction(), "[{\"limit\": -1}]");
   EXPECT_STREQ(download_extension_errors::kInvalidQueryLimit,
       error.c_str());
 }
 
 // Test searching using multiple conditions through multiple downloads.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
@@ skipping 10 matching lines @@
       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 264 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(download_extension_errors::kInvalidHeaderError,
                   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,
                 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",
-    "javascript:document.write(\\\"hello\\\");",
-    "javascript:return false;",
-    "ftp://example.com/example.txt",
+    "google.com/",
   };
 
   for (size_t index = 0; index < arraysize(kInvalidURLs); ++index) {
     EXPECT_STREQ(download_extension_errors::kInvalidURLError,
                   RunFunctionAndReturnError(new DownloadsDownloadFunction(),
                                             base::StringPrintf(
-        "[{\"url\": \"%s\"}]", kInvalidURLs[index])).c_str());
+        "[{\"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(kNotPermittedURLs); ++index) {
+    EXPECT_STREQ(download_extension_errors::kNotPermittedURLError,
+                  RunFunctionAndReturnError(new DownloadsDownloadFunction(),
+                                            base::StringPrintf(
+        "[{\"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 139 matching lines @@
 
   ASSERT_TRUE(WaitFor(events::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
                           "  \"incognito\": false,"
                           "  \"id\": %d,"
                           "  \"mime\": \"text/plain\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
                           result_id,
                           download_url.c_str())));
+  LOG(INFO) << "occam";
   ASSERT_TRUE(WaitFor(
       events::kOnDownloadDeterminingFilename,
       base::StringPrintf("[{\"id\": %d,"
                          "  \"filename\":\"slow.txt\"}]",
                          result_id)));
+  LOG(INFO) << "occam";
   ASSERT_TRUE(item->GetTargetFilePath().empty());
   ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   // Respond to the onDeterminingFilename.
   std::string error;
   ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename(
       browser()->profile(),
       false,
       GetExtensionId(),
       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)));
+  LOG(INFO) << "occam";
 
   item->ValidateDangerousDownload();
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
-                         "  \"dangerAccepted\": {"
-                         "    \"previous\":false,"
-                         "    \"current\":true}}]",
+                         "  \"danger\": {"
+                         "    \"previous\":\"file\","
+                         "    \"current\":\"accepted\"}}]",
                          result_id)));
+  LOG(INFO) << "occam";
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id)));
+  LOG(INFO) << "occam";
   EXPECT_EQ(downloads_directory().AppendASCII("overridden.swf"),
             item->GetTargetFilePath());
 }
 
 IN_PROC_BROWSER_TEST_F(
     DownloadExtensionTest,
     DownloadExtensionTest_OnDeterminingFilename_ReferencesParentInvalid) {
   GoOnTheRecord();
   LoadExtension("downloads_split");
   AddFilenameDeterminer();
@@ skipping 1050 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_;
 }