Revert 144807 - Rewrite DownloadsApiTest in C++.

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/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/message_loop.h"
 #include "base/scoped_temp_dir.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_observer.h"
 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
-#include "chrome/browser/extensions/extension_apitest.h"
-#include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_function_test_utils.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/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/web_contents.h"
-#include "content/public/common/page_transition_types.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 "ui/gfx/codec/png_codec.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_interface.h"
-#include "webkit/fileapi/file_system_url.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::DownloadPersistentStoreInfo;
 
 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();
   }
 };
 
-class DownloadsEventsListener : public content::NotificationObserver {
- public:
-  DownloadsEventsListener()
-    : waiting_(false) {
-    registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
-                   content::NotificationService::AllSources());
-  }
-
-  virtual ~DownloadsEventsListener() {
-    registrar_.Remove(this, chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
-                      content::NotificationService::AllSources());
-    STLDeleteElements(&events_);
-  }
-
-  class Event {
-   public:
-    Event(Profile* profile,
-          const std::string& event_name,
-          const std::string& json_args,
-          base::Time caught)
-      : profile_(profile),
-        event_name_(event_name),
-        json_args_(json_args),
-        args_(base::JSONReader::Read(json_args)),
-        caught_(caught) {
-    }
-
-    const base::Time& caught() { return caught_; }
-
-    bool Equals(const Event& other) {
-      if ((profile_ != other.profile_) ||
-          (event_name_ != other.event_name_))
-        return false;
-      if ((event_name_ == extension_event_names::kOnDownloadCreated ||
-           event_name_ == extension_event_names::kOnDownloadChanged) &&
-          args_.get() &&
-          other.args_.get()) {
-        base::ListValue* left_list = NULL;
-        base::DictionaryValue* left_dict = NULL;
-        base::ListValue* right_list = NULL;
-        base::DictionaryValue* right_dict = NULL;
-        if (!args_->GetAsList(&left_list) ||
-            !other.args_->GetAsList(&right_list) ||
-            !left_list->GetDictionary(0, &left_dict) ||
-            !right_list->GetDictionary(0, &right_dict))
-          return false;
-        for (base::DictionaryValue::Iterator iter(*left_dict);
-             iter.HasNext(); iter.Advance()) {
-          base::Value* right_value = NULL;
-          if (right_dict->HasKey(iter.key()) &&
-              right_dict->Get(iter.key(), &right_value) &&
-              !iter.value().Equals(right_value)) {
-            return false;
-          }
-        }
-        return true;
-      } else if ((event_name_ == extension_event_names::kOnDownloadErased) &&
-                 args_.get() &&
-                 other.args_.get()) {
-        int my_id = -1, other_id = -1;
-        return (args_->GetAsInteger(&my_id) &&
-                other.args_->GetAsInteger(&other_id) &&
-                my_id == other_id);
-      }
-      return json_args_ == other.json_args_;
-    }
-
-    std::string Debug() {
-      return base::StringPrintf("Event(%p, %s, %s, %f)",
-                                profile_,
-                                event_name_.c_str(),
-                                json_args_.c_str(),
-                                caught_.ToJsTime());
-    }
-
-   private:
-    Profile* profile_;
-    std::string event_name_;
-    std::string json_args_;
-    scoped_ptr<base::Value> args_;
-    base::Time caught_;
-
-    DISALLOW_COPY_AND_ASSIGN(Event);
-  };
-
-  typedef ExtensionDownloadsEventRouter::DownloadsNotificationSource
-    DownloadsNotificationSource;
-
-  void Observe(int type, const content::NotificationSource& source,
-               const content::NotificationDetails& details) {
-    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());
-          events_.push_back(new_event);
-          if (waiting_ &&
-              waiting_for_.get() &&
-              waiting_for_->Equals(*new_event)) {
-            waiting_ = false;
-            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)->Equals(*waiting_for_.get()))
-        return true;
-    }
-    waiting_ = true;
-    ui_test_utils::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_) {
-          LOG(INFO) << "Caught " << (*iter)->Debug();
-        }
-      }
-      if (waiting_for_.get()) {
-        LOG(INFO) << "Timed out waiting for " << waiting_for_->Debug();
-      }
-      waiting_ = false;
-    }
-    waiting_for_.reset();
-    last_wait_ = base::Time::Now();
-    return success;
-  }
-
- private:
-  void TimedOut() {
-    if (!waiting_for_.get())
-      return;
-    MessageLoopForUI::current()->Quit();
-  }
-
-  bool waiting_;
-  base::Time last_wait_;
-  scoped_ptr<Event> waiting_for_;
-  content::NotificationRegistrar registrar_;
-  std::deque<Event*> events_;
-
-  DISALLOW_COPY_AND_ASSIGN(DownloadsEventsListener);
-};
-
-class DownloadExtensionTest : public ExtensionApiTest {
- public:
-  DownloadExtensionTest()
-    : extension_(NULL),
-      incognito_browser_(NULL),
-      current_browser_(NULL) {
-  }
-
+class DownloadExtensionTest : public InProcessBrowserTest {
  protected:
   // Used with CreateHistoryDownloads
   struct HistoryDownloadInfo {
     // Filename to use. CreateHistoryDownloads will append this filename to the
     // temporary downloads directory specified by downloads_directory().
     const FilePath::CharType*   filename;
 
     // State for the download. Note that IN_PROGRESS downloads will be created
     // as CANCELLED.
     DownloadItem::DownloadState state;
 
     // Danger type for the download. Only use DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS
     // and DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT.
     content::DownloadDangerType danger_type;
   };
 
-  void LoadExtension(const char* name) {
-    // Store the created Extension object so that we can attach it to
-    // ExtensionFunctions.  Also load the extension in incognito profiles for
-    // testing incognito.
-    extension_ = LoadExtensionIncognito(test_data_dir_.AppendASCII(name));
-    CHECK(extension_);
-  }
-
-  Browser* current_browser() { return current_browser_; }
+  virtual Browser* current_browser() { return browser(); }
 
   // InProcessBrowserTest
   virtual void SetUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
     InProcessBrowserTest::SetUpOnMainThread();
-    GoOnTheRecord();
     CreateAndSetDownloadsDirectory();
     current_browser()->profile()->GetPrefs()->SetBoolean(
         prefs::kPromptForDownload, false);
-    GetOnRecordManager()->RemoveAllDownloads();
-    events_listener_.reset(new DownloadsEventsListener());
+    GetDownloadManager()->RemoveAllDownloads();
   }
 
-  void GoOnTheRecord() { current_browser_ = browser(); }
-
-  void GoOffTheRecord() {
-    if (!incognito_browser_) {
-      incognito_browser_ = CreateIncognitoBrowser();
-      GetOffRecordManager()->RemoveAllDownloads();
-    }
-    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) {
-    if (!WaitFor(extension_event_names::kOnDownloadCreated, on_created_event))
-      return false;
-    // The item may or may not be interrupted before the onCreated event fires.
-    if (item->IsInterrupted()) {
-      scoped_ptr<base::Value> args(base::JSONReader::Read(on_created_event));
-      base::ListValue* args_list = NULL;
-      base::DictionaryValue* args_dict = NULL;
-      if (!args->GetAsList(&args_list) ||
-          !args_list->GetDictionary(0, &args_dict))
-        return false;
-      args_dict->SetString("state", "interrupted");
-      args_dict->SetInteger("error", expected_error);
-      std::string created_error;
-      base::JSONWriter::Write(args_list, &created_error);
-      // This is not waiting for a different event, it's refining the
-      // expectations on the onCreated event that was just caught. Specifically,
-      // if a DownloadItem is already interrupted by the time the onCreated
-      // event fires, then the onCreated event should already describe the
-      // error.
-      return WaitFor(extension_event_names::kOnDownloadCreated, created_error);
-    } else {
-      return WaitFor(extension_event_names::kOnDownloadChanged,
-          base::StringPrintf("[{\"id\": %d,"
-                              "  \"error\": {\"current\": %d},"
-                              "  \"state\": {"
-                              "    \"previous\": \"in_progress\","
-                              "    \"current\": \"interrupted\"}}]",
-                              item->GetId(),
-                              expected_error));
-    }
-  }
-
-  std::string GetExtensionURL() {
-    return extension_->url().spec();
-  }
-
-  std::string GetFilename(const char* path) {
-    std::string result =
-      downloads_directory_.path().AppendASCII(path).AsUTF8Unsafe();
-#if defined(OS_WIN)
-    for (std::string::size_type next = result.find("\\");
-         next != std::string::npos;
-         next = result.find("\\", next)) {
-      result.replace(next, 1, "\\\\");
-      next += 2;
-    }
-#endif
-    return result;
-  }
-
-  DownloadManager* GetOnRecordManager() {
-    return BrowserContext::GetDownloadManager(browser()->profile());
-  }
-  DownloadManager* GetOffRecordManager() {
-    return BrowserContext::GetDownloadManager(
-        browser()->profile()->GetOffTheRecordProfile());
-  }
-  DownloadManager* GetCurrentManager() {
-    return (current_browser_ == incognito_browser_) ?
-      GetOffRecordManager() : GetOnRecordManager();
+  virtual DownloadManager* GetDownloadManager() {
+    return BrowserContext::GetDownloadManager(current_browser()->profile());
   }
 
   // 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);
     for (size_t i = 0; i < count; ++i) {
       DownloadPersistentStoreInfo entry(
           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);
     }
-    GetOnRecordManager()->OnPersistentStoreQueryComplete(&entries);
-    GetOnRecordManager()->GetAllDownloads(FilePath(), items);
+    GetDownloadManager()->OnPersistentStoreQueryComplete(&entries);
+    GetDownloadManager()->GetAllDownloads(FilePath(), 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) {
@@ skipping 13 matching lines @@
       GURL slow_download_url(URLRequestSlowDownloadJob::kUnknownSizeUrl);
       ui_test_utils::NavigateToURLWithDisposition(
           current_browser(), slow_download_url, CURRENT_TAB,
           ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
       observer->WaitForFinished();
       EXPECT_EQ(
           1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
       // We don't expect a select file dialog.
       ASSERT_FALSE(observer->select_file_dialog_seen());
     }
-    GetCurrentManager()->GetAllDownloads(FilePath(), items);
+    GetDownloadManager()->GetAllDownloads(FilePath(), items);
     ASSERT_EQ(count, items->size());
   }
 
   DownloadItem* CreateSlowTestDownload() {
     scoped_ptr<DownloadTestObserver> observer(
         CreateInProgressDownloadObserver(1));
     GURL slow_download_url(URLRequestSlowDownloadJob::kUnknownSizeUrl);
-    DownloadManager* manager = GetCurrentManager();
+    DownloadManager* manager = GetDownloadManager();
 
     EXPECT_EQ(0, manager->InProgressCount());
     if (manager->InProgressCount() != 0)
       return NULL;
 
     ui_test_utils::NavigateToURLWithDisposition(
         current_browser(), slow_download_url, CURRENT_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
     observer->WaitForFinished();
@@ skipping 23 matching lines @@
     GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
     ui_test_utils::NavigateToURLWithDisposition(
         current_browser(), finish_url, NEW_FOREGROUND_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   }
 
   DownloadTestObserver* CreateDownloadObserver(size_t download_count) {
     return new DownloadTestObserverTerminal(
-        GetCurrentManager(), download_count, true,
+        GetDownloadManager(), download_count, true,
         DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   DownloadTestObserver* CreateInProgressDownloadObserver(
       size_t download_count) {
-    return new DownloadTestObserverInProgress(
-        GetCurrentManager(), download_count, true);
-  }
-
-  bool RunFunction(UIThreadExtensionFunction* function,
-                   const std::string& args) {
-    scoped_refptr<UIThreadExtensionFunction> delete_function(function);
-    SetUpExtensionFunction(function);
-    return extension_function_test_utils::RunFunction(
-        function, args, browser(), GetFlags());
+    return new DownloadTestObserverInProgress(GetDownloadManager(),
+                                              download_count,
+                                              true);
   }
 
   extension_function_test_utils::RunFunctionFlags GetFlags() {
     return current_browser()->profile()->IsOffTheRecord() ?
            extension_function_test_utils::INCLUDE_INCOGNITO :
            extension_function_test_utils::NONE;
   }
 
   // extension_function_test_utils::RunFunction*() only uses browser for its
   // profile(), so pass it the on-record browser so that it always uses the
-  // on-record profile to match real-life behavior.
+  // on-record profile.
+
+  bool RunFunction(UIThreadExtensionFunction* function,
+                   const std::string& args) {
+    // extension_function_test_utils::RunFunction() does not take
+    // ownership of |function|.
+    scoped_refptr<ExtensionFunction> function_owner(function);
+    return extension_function_test_utils::RunFunction(
+        function, args, browser(), GetFlags());
+  }
 
   base::Value* RunFunctionAndReturnResult(UIThreadExtensionFunction* function,
                                           const std::string& args) {
-    SetUpExtensionFunction(function);
     return extension_function_test_utils::RunFunctionAndReturnResult(
         function, args, browser(), GetFlags());
   }
 
   std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                         const std::string& args) {
-    SetUpExtensionFunction(function);
     return extension_function_test_utils::RunFunctionAndReturnError(
         function, args, browser(), GetFlags());
   }
 
   bool RunFunctionAndReturnString(UIThreadExtensionFunction* function,
                                   const std::string& args,
                                   std::string* result_string) {
-    SetUpExtensionFunction(function);
     scoped_ptr<base::Value> result(RunFunctionAndReturnResult(function, args));
     EXPECT_TRUE(result.get());
     return result.get() && result->GetAsString(result_string);
   }
 
   std::string DownloadItemIdAsArgList(const DownloadItem* download_item) {
     return base::StringPrintf("[%d]", download_item->GetId());
   }
 
   // Checks if a data URL encoded image is a PNG of a given size.
@@ skipping 16 matching lines @@
         gfx::PNGCodec::FORMAT_RGBA, &decoded_data,
         &width, &height));
     EXPECT_EQ(expected_size, width);
     EXPECT_EQ(expected_size, height);
   }
 
   const FilePath& downloads_directory() {
     return downloads_directory_.path();
   }
 
-  DownloadsEventsListener* events_listener() { return events_listener_.get(); }
-
  private:
-  void SetUpExtensionFunction(UIThreadExtensionFunction* function) {
-    if (extension_) {
-      // Recreate the tab each time for insulation.
-      TabContents* tab = current_browser()->AddSelectedTabWithURL(
-          extension_->GetResourceURL("empty.html"),
-          content::PAGE_TRANSITION_LINK);
-      function->set_extension(extension_);
-      function->SetRenderViewHost(tab->web_contents()->GetRenderViewHost());
-    }
-  }
-
   void CreateAndSetDownloadsDirectory() {
     ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
     current_browser()->profile()->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory,
         downloads_directory_.path());
   }
 
   ScopedTempDir downloads_directory_;
-  const extensions::Extension* extension_;
+};
+
+class DownloadExtensionTestIncognito : public DownloadExtensionTest {
+ public:
+  virtual Browser* current_browser() OVERRIDE { return current_browser_; }
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    GoOnTheRecord();
+    DownloadExtensionTest::SetUpOnMainThread();
+    incognito_browser_ = CreateIncognitoBrowser();
+    GoOffTheRecord();
+    GetDownloadManager()->RemoveAllDownloads();
+  }
+
+  void GoOnTheRecord() { current_browser_ = browser(); }
+  void GoOffTheRecord() { current_browser_ = incognito_browser_; }
+
+ private:
   Browser* incognito_browser_;
   Browser* current_browser_;
-  scoped_ptr<DownloadsEventsListener> events_listener_;
-
-  DISALLOW_COPY_AND_ASSIGN(DownloadExtensionTest);
 };
 
 class MockIconExtractorImpl : public DownloadFileIconExtractor {
  public:
   MockIconExtractorImpl(const FilePath& path, IconLoader::IconSize icon_size,
                         const std::string& response)
     : expected_path_(path),
       expected_icon_size_(icon_size),
       response_(response) {
   }
@@ skipping 58 matching lines @@
       if ((*item)->IsInProgress())
         (*item)->Cancel(true);
     }
   }
 
  private:
   DownloadManager::DownloadVector* items_;
   DISALLOW_COPY_AND_ASSIGN(ScopedItemVectorCanceller);
 };
 
-class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
- public:
-  explicit TestProtocolHandler(
-      webkit_blob::BlobStorageController* blob_storage_controller)
-      : blob_storage_controller_(blob_storage_controller) {}
-
-  virtual ~TestProtocolHandler() {}
-
-  virtual net::URLRequestJob* MaybeCreateJob(
-      net::URLRequest* request) const OVERRIDE {
-    return new webkit_blob::BlobURLRequestJob(
-        request,
-        blob_storage_controller_->GetBlobDataFromUrl(request->url()),
-        base::MessageLoopProxy::current());
-  }
-
- private:
-  webkit_blob::BlobStorageController* const blob_storage_controller_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestProtocolHandler);
-};
-
-class TestURLRequestContext : public net::URLRequestContext {
- public:
-  TestURLRequestContext()
-      : blob_storage_controller_(new webkit_blob::BlobStorageController) {
-    // Job factory owns the protocol handler.
-    job_factory_.SetProtocolHandler(
-        "blob", new TestProtocolHandler(blob_storage_controller_.get()));
-    set_job_factory(&job_factory_);
-  }
-
-  virtual ~TestURLRequestContext() {}
-
-  webkit_blob::BlobStorageController* blob_storage_controller() const {
-    return blob_storage_controller_.get();
-  }
-
- private:
-  net::URLRequestJobFactory job_factory_;
-  scoped_ptr<webkit_blob::BlobStorageController> blob_storage_controller_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestURLRequestContext);
-};
-
-// TODO(benjhayden): Comment.
-class HTML5FileWriter {
- public:
-  HTML5FileWriter(
-      Profile* profile,
-      const std::string& filename,
-      const std::string& origin,
-      DownloadsEventsListener* events_listener,
-      const std::string& payload)
-    : profile_(profile),
-      filename_(filename),
-      origin_(origin),
-      events_listener_(events_listener),
-      blob_data_(new webkit_blob::BlobData()),
-      payload_(payload),
-      fs_(BrowserContext::GetFileSystemContext(profile_)) {
-    CHECK(profile_);
-    CHECK(events_listener_);
-    CHECK(fs_);
-  }
-
-  ~HTML5FileWriter() {
-    CHECK(BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-        &HTML5FileWriter::TearDownURLRequestContext, base::Unretained(this))));
-    events_listener_->WaitFor(profile_, kURLRequestContextToreDown, "");
-  }
-
-  bool WriteFile() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    fs_->OpenFileSystem(
-        GURL(origin_),
-        fileapi::kFileSystemTypeTemporary,
-        kCreateFileSystem,
-        base::Bind(&HTML5FileWriter::OpenFileSystemCallback,
-                   base::Unretained(this)));
-    return events_listener_->WaitFor(profile_, kHTML5FileWritten, filename_);
-  }
-
- private:
-  static const char kHTML5FileWritten[];
-  static const char kURLRequestContextToreDown[];
-  static const bool kExclusive = true;
-  static const bool kCreateFileSystem = true;
-
-  GURL blob_url() const { return GURL("blob:" + filename_); }
-
-  void OpenFileSystemCallback(
-      base::PlatformFileError result,
-      const std::string& fs_name,
-      const GURL& root) {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    root_ = root.spec();
-    CHECK(BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-        &HTML5FileWriter::CreateFile, base::Unretained(this))));
-  }
-
-  fileapi::FileSystemOperationInterface* operation() {
-    return fs_->CreateFileSystemOperation(fileapi::FileSystemURL(GURL(root_)));
-  }
-
-  void CreateFile() {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    operation()->CreateFile(fileapi::FileSystemURL(GURL(root_ + filename_)),
-        kExclusive, base::Bind(
-            &HTML5FileWriter::CreateFileCallback, base::Unretained(this)));
-  }
-
-  void CreateFileCallback(base::PlatformFileError result) {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    CHECK_EQ(base::PLATFORM_FILE_OK, result);
-    blob_data_->AppendData(payload_);
-    url_request_context_.reset(new TestURLRequestContext());
-    url_request_context_->blob_storage_controller()->AddFinishedBlob(
-        blob_url(), blob_data_);
-    operation()->Write(
-        url_request_context_.get(),
-        fileapi::FileSystemURL(GURL(root_ + filename_)),
-        blob_url(),
-        0,  // offset
-        base::Bind(&HTML5FileWriter::WriteCallback, base::Unretained(this)));
-  }
-
-  void WriteCallback(
-      base::PlatformFileError result,
-      int64 bytes,
-      bool complete) {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    CHECK_EQ(base::PLATFORM_FILE_OK, result);
-    CHECK(BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-        &HTML5FileWriter::NotifyWritten, base::Unretained(this))));
-  }
-
-  void NotifyWritten() {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    DownloadsEventsListener::DownloadsNotificationSource notification_source;
-    notification_source.event_name = kHTML5FileWritten;
-    notification_source.profile = profile_;
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
-        content::Source<DownloadsEventsListener::DownloadsNotificationSource>(
-          &notification_source),
-        content::Details<std::string>(&filename_));
-  }
-
-  void TearDownURLRequestContext() {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    url_request_context_->blob_storage_controller()->RemoveBlob(blob_url());
-    url_request_context_.reset();
-    CHECK(BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-        &HTML5FileWriter::NotifyURLRequestContextToreDown,
-        base::Unretained(this))));
-  }
-
-  void NotifyURLRequestContextToreDown() {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    DownloadsEventsListener::DownloadsNotificationSource notification_source;
-    notification_source.event_name = kURLRequestContextToreDown;
-    notification_source.profile = profile_;
-    std::string empty_args;
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
-        content::Source<DownloadsEventsListener::DownloadsNotificationSource>(
-          &notification_source),
-        content::Details<std::string>(&empty_args));
-  }
-
-  Profile* profile_;
-  std::string filename_;
-  std::string origin_;
-  std::string root_;
-  DownloadsEventsListener* events_listener_;
-  scoped_refptr<webkit_blob::BlobData> blob_data_;
-  std::string payload_;
-  scoped_ptr<TestURLRequestContext> url_request_context_;
-  fileapi::FileSystemContext* fs_;
-
-  DISALLOW_COPY_AND_ASSIGN(HTML5FileWriter);
-};
-
-const char HTML5FileWriter::kHTML5FileWritten[] = "html5_file_written";
-const char HTML5FileWriter::kURLRequestContextToreDown[] =
-  "url_request_context_tore_down";
-
-}  // namespace
+} // namespace
 
 IN_PROC_BROWSER_TEST_F(
     DownloadExtensionTest, DownloadExtensionTest_PauseResumeCancel) {
   DownloadItem* download_item = CreateSlowTestDownload();
   ASSERT_TRUE(download_item);
 
   // Call pause().  It should succeed and the download should be paused on
   // return.
   EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(),
                           DownloadItemIdAsArgList(download_item)));
@@ skipping 34 matching lines @@
       new DownloadsPauseFunction(), DownloadItemIdAsArgList(download_item));
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                error.c_str());
 
   // Calling resume on a non-active download yields kInvalidOperationError
   error = RunFunctionAndReturnError(
       new DownloadsResumeFunction(), DownloadItemIdAsArgList(download_item));
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                error.c_str());
 
-  // Calling paused on a non-existent download yields kInvalidOperationError.
-  error = RunFunctionAndReturnError(
-      new DownloadsPauseFunction(), "[-42]");
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
-               error.c_str());
-
-  // Calling resume on a non-existent download yields kInvalidOperationError
-  error = RunFunctionAndReturnError(
-      new DownloadsResumeFunction(), "[-42]");
-  EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
-               error.c_str());
+  // Calling pause()/resume()/cancel() with invalid download Ids is
+  // tested in the API test (DownloadsApiTest).
 }
 
 // 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);
 
   // Get the icon for the in-progress download.  This call should succeed even
@@ skipping 75 matching lines @@
       expected_path, IconLoader::NORMAL, ""));
   std::string error = RunFunctionAndReturnError(function.release(), args);
   EXPECT_STREQ(download_extension_errors::kIconNotFoundError,
                error.c_str());
 
   // Once the download item is deleted, we should return kInvalidOperationError.
   download_item->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
   error = RunFunctionAndReturnError(new DownloadsGetFileIconFunction(), args);
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                error.c_str());
+
+  // Asking for icons of other (invalid) sizes is tested in the API test
+  // (DownloadsApiTest).
 }
 
 // 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[] = {
     { FILE_PATH_LITERAL("real.txt"),
@@ skipping 35 matching lines @@
     function->SetIconExtractorForTesting(new MockIconExtractorImpl(
         (*iter)->GetFullPath(), IconLoader::NORMAL, "hello"));
     EXPECT_TRUE(RunFunctionAndReturnString(function.release(), args,
                                            &result_string));
     EXPECT_STREQ("hello", result_string.c_str());
   }
 
   // The temporary files should be cleaned up when the 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(), "[{}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(1UL, result_list->GetSize());
 }
 
-// Test the |filenameRegex| parameter for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchFilenameRegex) {
   const HistoryDownloadInfo kHistoryInfo[] = {
     { FILE_PATH_LITERAL("foobar"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS },
     { FILE_PATH_LITERAL("baz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }
   };
   DownloadManager::DownloadVector all_downloads;
   ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo),
                                      &all_downloads));
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{\"filenameRegex\": \"foobar\"}]"));
   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));
   int item_id = -1;
   ASSERT_TRUE(item_value->GetInteger("id", &item_id));
   ASSERT_EQ(0, item_id);
 }
 
-// Test the |id| parameter for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, DownloadExtensionTest_SearchId) {
   DownloadManager::DownloadVector items;
   CreateSlowTestDownloads(2, &items);
   ScopedItemVectorCanceller delete_items(&items);
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{\"id\": 0}]"));
   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));
   int item_id = -1;
   ASSERT_TRUE(item_value->GetInteger("id", &item_id));
   ASSERT_EQ(0, item_id);
 }
 
-// Test specifying both the |id| and |filename| parameters for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchIdAndFilename) {
   DownloadManager::DownloadVector items;
   CreateSlowTestDownloads(2, &items);
   ScopedItemVectorCanceller delete_items(&items);
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsSearchFunction(),
-      "[{\"id\": 0, \"filename\": \"foobar\"}]"));
+      new DownloadsSearchFunction(), "[{\"id\": 0,\"filename\": \"foobar\"}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(0UL, result_list->GetSize());
 }
 
-// Test a single |orderBy| parameter for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchOrderBy) {
   const HistoryDownloadInfo kHistoryInfo[] = {
     { FILE_PATH_LITERAL("zzz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS },
     { FILE_PATH_LITERAL("baz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }
   };
@@ skipping 11 matching lines @@
   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));
   ASSERT_TRUE(item1_value->GetString("filename", &item1_name));
   ASSERT_GT(items[0]->GetFullPath().value(), items[1]->GetFullPath().value());
   ASSERT_LT(item0_name, item1_name);
 }
 
-// Test specifying an empty |orderBy| parameter for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchOrderByEmpty) {
   const HistoryDownloadInfo kHistoryInfo[] = {
     { FILE_PATH_LITERAL("zzz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS },
     { FILE_PATH_LITERAL("baz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }
   };
@@ skipping 11 matching lines @@
   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));
   ASSERT_TRUE(item1_value->GetString("filename", &item1_name));
   ASSERT_GT(items[0]->GetFullPath().value(), items[1]->GetFullPath().value());
   ASSERT_GT(item0_name, item1_name);
 }
 
-// Test the |danger| option for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchDanger) {
   const HistoryDownloadInfo kHistoryInfo[] = {
     { FILE_PATH_LITERAL("zzz"),
       DownloadItem::COMPLETE,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT },
     { 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(), "[{\"danger\": \"content\"}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(1UL, result_list->GetSize());
 }
 
-// Test the |state| option for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchState) {
   DownloadManager::DownloadVector items;
   CreateSlowTestDownloads(2, &items);
   ScopedItemVectorCanceller delete_items(&items);
 
   items[0]->Cancel(true);
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{\"state\": \"in_progress\"}]"));
   ASSERT_TRUE(result.get());
   base::ListValue* result_list = NULL;
   ASSERT_TRUE(result->GetAsList(&result_list));
   ASSERT_EQ(1UL, result_list->GetSize());
 }
 
-// Test the |limit| option for search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     DownloadExtensionTest_SearchLimit) {
   DownloadManager::DownloadVector items;
   CreateSlowTestDownloads(2, &items);
   ScopedItemVectorCanceller delete_items(&items);
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{\"limit\": 1}]"));
   ASSERT_TRUE(result.get());
   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,
       error.c_str());
   error = RunFunctionAndReturnError(
       new DownloadsSearchFunction(), "[{\"danger\": \"goat\"}]");
   EXPECT_STREQ(download_extension_errors::kInvalidDangerTypeError,
       error.c_str());
   error = RunFunctionAndReturnError(
       new DownloadsSearchFunction(), "[{\"state\": \"goat\"}]");
   EXPECT_STREQ(download_extension_errors::kInvalidStateError,
       error.c_str());
   error = RunFunctionAndReturnError(
       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,
     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"),
@@ skipping 14 matching lines @@
   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));
   FilePath::StringType item_name;
   ASSERT_TRUE(item_value->GetString("filename", &item_name));
   ASSERT_EQ(items[2]->GetFullPath().value(), item_name);
 }
 
-// Test that incognito downloads are only visible in incognito contexts, and
-// test that on-record downloads are visible in both incognito and on-record
-// contexts, for DownloadsSearchFunction, DownloadsPauseFunction,
-// DownloadsResumeFunction, and DownloadsCancelFunction.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
+IN_PROC_BROWSER_TEST_F(DownloadExtensionTestIncognito,
     DownloadExtensionTest_SearchPauseResumeCancelGetFileIconIncognito) {
   scoped_ptr<base::Value> result_value;
   base::ListValue* result_list = NULL;
   base::DictionaryValue* result_dict = NULL;
   FilePath::StringType filename;
   bool is_incognito = false;
   std::string error;
   std::string on_item_arg;
   std::string off_item_arg;
   std::string result_string;
 
   // Set up one on-record item and one off-record item.
-  // Set up the off-record item first because otherwise there are mysteriously 3
-  // items total instead of 2.
-  // TODO(benjhayden): Figure out where the third item comes from.
-  GoOffTheRecord();
-  DownloadItem* off_item = CreateSlowTestDownload();
-  ASSERT_TRUE(off_item);
-  ASSERT_TRUE(off_item->IsOtr());
-  off_item_arg = DownloadItemIdAsArgList(off_item);
 
   GoOnTheRecord();
   DownloadItem* on_item = CreateSlowTestDownload();
   ASSERT_TRUE(on_item);
   ASSERT_FALSE(on_item->IsOtr());
   on_item_arg = DownloadItemIdAsArgList(on_item);
+
+  GoOffTheRecord();
+  DownloadItem* off_item = CreateSlowTestDownload();
+  ASSERT_TRUE(off_item);
+  ASSERT_TRUE(off_item->IsOtr());
   ASSERT_TRUE(on_item->GetFullPath() != off_item->GetFullPath());
+  off_item_arg = DownloadItemIdAsArgList(off_item);
 
   // Extensions running in the incognito window should have access to both
   // items because the Test extension is in spanning mode.
-  GoOffTheRecord();
   result_value.reset(RunFunctionAndReturnResult(
       new DownloadsSearchFunction(), "[{}]"));
   ASSERT_TRUE(result_value.get());
   ASSERT_TRUE(result_value->GetAsList(&result_list));
   ASSERT_EQ(2UL, result_list->GetSize());
   ASSERT_TRUE(result_list->GetDictionary(0, &result_dict));
   ASSERT_TRUE(result_dict->GetString("filename", &filename));
   ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito));
   EXPECT_TRUE(on_item->GetFullPath() == FilePath(filename));
   EXPECT_FALSE(is_incognito);
@@ skipping 25 matching lines @@
   error = RunFunctionAndReturnError(new DownloadsResumeFunction(),
                                     off_item_arg);
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                error.c_str());
   error = RunFunctionAndReturnError(
       new DownloadsGetFileIconFunction(),
       base::StringPrintf("[%d, {}]", off_item->GetId()));
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                error.c_str());
 
+  // TODO(benjhayden): Test incognito_split_mode() extension.
+  // TODO(benjhayden): Test download(), onCreated, onChanged, onErased.
+
   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(
       new DownloadsGetFileIconFunction(),
       base::StringPrintf("[%d, {}]", on_item->GetId()), &result_string));
   EXPECT_TRUE(RunFunctionAndReturnString(
       new DownloadsGetFileIconFunction(),
@@ skipping 37 matching lines @@
   EXPECT_TRUE(off_item->IsCancelled());
   error = RunFunctionAndReturnError(new DownloadsPauseFunction(),
                                     off_item_arg);
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                error.c_str());
   error = RunFunctionAndReturnError(new DownloadsResumeFunction(),
                                     off_item_arg);
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                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");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("slow?0").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsDownloadFunction(), base::StringPrintf(
-          "[{\"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"text/plain\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          GetFilename("slow.txt.crdownload").c_str(),
-                          download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]",
-                          result_id,
-                          GetFilename("slow.txt.crdownload").c_str(),
-                          GetFilename("slow.txt").c_str())));
-}
-
-// Test that we can start a download from an incognito context, and that the
-// download knows that it's incognito.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_Incognito) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  GoOffTheRecord();
-  std::string download_url = test_server()->GetURL("slow?0").spec();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsDownloadFunction(), base::StringPrintf(
-          "[{\"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
-                          "  \"incognito\": true,"
-                          "  \"mime\": \"text/plain\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          GetFilename("slow.txt.crdownload").c_str(),
-                          download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\":%d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"state\": {"
-                          "    \"current\": \"complete\","
-                          "    \"previous\": \"in_progress\"}}]",
-                          result_id,
-                          GetFilename("slow.txt.crdownload").c_str(),
-                          GetFilename("slow.txt").c_str())));
-}
-
-// Test that we disallow certain headers case-insensitively.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_UnsafeHeaders) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  GoOnTheRecord();
-
-  static const char* kUnsafeHeaders[] = {
-    "Accept-chArsEt",
-    "accept-eNcoding",
-    "coNNection",
-    "coNteNt-leNgth",
-    "cooKIE",
-    "cOOkie2",
-    "coNteNt-traNsfer-eNcodiNg",
-    "dAtE",
-    "ExpEcT",
-    "hOsT",
-    "kEEp-aLivE",
-    "rEfErEr",
-    "tE",
-    "trAilER",
-    "trANsfer-eNcodiNg",
-    "upGRAde",
-    "usER-agENt",
-    "viA",
-    "pRoxY-",
-    "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,
-                  RunFunctionAndReturnError(new DownloadsDownloadFunction(),
-                                            base::StringPrintf(
-        "[{\"url\": \"%s\","
-        "  \"filename\": \"unsafe-header-%lu.txt\","
-        "  \"headers\": [{"
-        "    \"name\": \"%s\","
-        "    \"value\": \"unsafe\"}]}]",
-        download_url.c_str(), 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");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("slow?0").spec();
-  GoOnTheRecord();
-
-  EXPECT_STREQ(download_extension_errors::kGenericError,
-                RunFunctionAndReturnError(new DownloadsDownloadFunction(),
-                                          base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"sub/dir/ect/ory.txt\"}]",
-      download_url.c_str())).c_str());
-}
-
-// Test that invalid filenames are disallowed.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_InvalidFilename) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("slow?0").spec();
-  GoOnTheRecord();
-
-  EXPECT_STREQ(download_extension_errors::kGenericError,
-                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",
-  };
-
-  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());
-  }
-}
-
-// 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");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("slow?0#fragment").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsDownloadFunction(), base::StringPrintf(
-          "[{\"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"text/plain\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          GetFilename("slow.txt.crdownload").c_str(),
-                          download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]",
-                          result_id,
-                          GetFilename("slow.txt.crdownload").c_str(),
-                          GetFilename("slow.txt").c_str())));
-}
-
-// Valid data URLs are valid URLs.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_DataURL) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = "data:text/plain,hello";
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"data.txt\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"text/plain\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          GetFilename("data.txt.crdownload").c_str(),
-                          download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]",
-                          result_id,
-                          GetFilename("data.txt.crdownload").c_str(),
-                          GetFilename("data.txt").c_str())));
-}
-
-// Valid file URLs are valid URLs.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_File) {
-  GoOnTheRecord();
-  CHECK(StartTestServer());
-  LoadExtension("downloads_split");
-  std::string download_url = "file:///";
-#if defined(OS_WIN)
-  download_url += "C:/";
-#endif
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"file.txt\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"text/html\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          GetFilename("file.txt.crdownload").c_str(),
-                          download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]",
-                          result_id,
-                          GetFilename("file.txt.crdownload").c_str(),
-                          GetFilename("file.txt").c_str())));
-}
-
-// Test that auth-basic-succeed would fail if the resource requires the
-// Authorization header and chrome fails to propagate it back to the server.
-// This tests both that testserver.py does not succeed when it should fail as
-// well as how the downloads extension API exposes the failure to extensions.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_AuthBasic_Fail) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("auth-basic").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"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()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(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())));
-}
-
-// Test that DownloadsDownloadFunction propagates |headers| to the URLRequest.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_Headers) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("files/downloads/"
-      "a_zip_file.zip?expected_headers=Foo:bar&expected_headers=Qx:yo").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"headers-succeed.txt\","
-      "  \"headers\": ["
-      "    {\"name\": \"Foo\", \"value\": \"bar\"},"
-      "    {\"name\": \"Qx\", \"value\":\"yo\"}]}]",
-      download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"application/octet-stream\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          download_url.c_str())));
-  std::string incomplete_filename = GetFilename(
-      "headers-succeed.txt.crdownload");
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]",
-                          result_id,
-                          incomplete_filename.c_str(),
-                          GetFilename("headers-succeed.txt").c_str())));
-}
-
-// Test that headers-succeed would fail if the resource requires the headers and
-// chrome fails to propagate them back to the server.  This tests both that
-// testserver.py does not succeed when it should fail as well as how the
-// downloads extension api exposes the failure to extensions.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_Headers_Fail) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("files/downloads/"
-      "a_zip_file.zip?expected_headers=Foo:bar&expected_headers=Qx:yo").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"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()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(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())));
-}
-
-// Test that DownloadsDownloadFunction propagates the Authorization header
-// correctly.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_AuthBasic) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("auth-basic").spec();
-  // This is just base64 of 'username:secret'.
-  static const char* kAuthorization = "dXNlcm5hbWU6c2VjcmV0";
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"auth-basic-succeed.txt\","
-      "  \"headers\": [{"
-      "    \"name\": \"Authorization\","
-      "    \"value\": \"Basic %s\"}]}]",
-      download_url.c_str(), kAuthorization)));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"text/html\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]", result_id)));
-}
-
-// Test that DownloadsDownloadFunction propagates the |method| and |body|
-// parameters to the URLRequest.
-IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
-                       DownloadExtensionTest_Download_Post) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("files/post/downloads/"
-      "a_zip_file.zip?expected_body=BODY").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"filename\": \"post-succeed.txt\","
-      "  \"method\": \"POST\","
-      "  \"body\": \"BODY\"}]",
-      download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"application/octet-stream\","
-                          "  \"paused\": false,"
-                          "  \"bytesReceived\": 164,"
-                          "  \"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]", result_id)));
-}
-
-// Test that downloadPostSuccess would fail if the resource requires the POST
-// method, and chrome fails to propagate the |method| 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_Get) {
-  LoadExtension("downloads_split");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("files/post/downloads/"
-      "a_zip_file.zip?expected_body=BODY").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-        new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"body\": \"BODY\","
-      "  \"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()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(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())));
-}
-
-// 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");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL("files/post/downloads/"
-      "a_zip_file.zip?expected_body=BODY").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsDownloadFunction(), base::StringPrintf(
-      "[{\"url\": \"%s\","
-      "  \"method\": \"POST\","
-      "  \"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()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(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())));
-}
-
-// 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");
-  CHECK(StartTestServer());
-  std::string download_url = test_server()->GetURL(
-      "download-known-size").spec();
-  GoOnTheRecord();
-
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsDownloadFunction(), base::StringPrintf(
-          "[{\"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"application/octet-stream\","
-                          "  \"paused\": false,"
-                          "  \"id\": %d,"
-                          "  \"url\": \"%s\"}]",
-                          result_id,
-                          download_url.c_str())));
-  item->Cancel(true);
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"error\": {\"current\": 40},"
-                          "  \"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) {
-  static const char* kPayloadData = "on the record\ndata";
-  GoOnTheRecord();
-  LoadExtension("downloads_split");
-  HTML5FileWriter html5_file_writer(
-      browser()->profile(),
-      "on_record.txt",
-      GetExtensionURL(),
-      events_listener(),
-      kPayloadData);
-  ASSERT_TRUE(html5_file_writer.WriteFile());
-
-  std::string download_url = "filesystem:" + GetExtensionURL() +
-    "temporary/on_record.txt";
-  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
-      new DownloadsDownloadFunction(), base::StringPrintf(
-          "[{\"url\": \"%s\"}]", download_url.c_str())));
-  ASSERT_TRUE(result.get());
-  int result_id = -1;
-  ASSERT_TRUE(result->GetAsInteger(&result_id));
-
-  DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
-  if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
-  ASSERT_TRUE(item);
-  ScopedCancellingItem canceller(item);
-  ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
-
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
-      base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"text/plain\","
-                          "  \"paused\": false,"
-                          "  \"url\": \"%s\"}]",
-                          GetFilename("on_record.txt.crdownload").c_str(),
-                          download_url.c_str())));
-  ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
-      base::StringPrintf("[{\"id\": %d,"
-                          "  \"filename\": {"
-                          "    \"previous\": \"%s\","
-                          "    \"current\": \"%s\"},"
-                          "  \"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());
-}