Move ExtensionEventRouter and related into extensions namespace

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/event_names.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/browser_tabstrip.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"
@@ skipping 20 matching lines @@
 #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 events = extensions::event_names;
+
 namespace {
 
 // Comparator that orders download items by their ID. Can be used with
 // std::sort.
 struct DownloadIdComparator {
   bool operator() (DownloadItem* first, DownloadItem* second) {
     return first->GetId() < second->GetId();
   }
 };
 
@@ skipping 23 matching lines @@
         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) &&
+      if ((event_name_ == events::kOnDownloadCreated ||
+           event_name_ == events::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) &&
+      } else if ((event_name_ == events::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_;
     }
 
@@ skipping 149 matching lines @@
     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))
+    if (!WaitFor(events::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);
+      return WaitFor(events::kOnDownloadCreated, created_error);
     } else {
-      return WaitFor(extension_event_names::kOnDownloadChanged,
+      return WaitFor(events::kOnDownloadChanged,
           base::StringPrintf("[{\"id\": %d,"
                               "  \"error\": {\"current\": %d},"
                               "  \"state\": {"
                               "    \"previous\": \"in_progress\","
                               "    \"current\": \"interrupted\"}}]",
                               item->GetId(),
                               expected_error));
     }
   }
 
@@ skipping 1164 matching lines @@
           "[{\"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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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())));
@@ skipping 13 matching lines @@
           "[{\"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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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())));
@@ skipping 126 matching lines @@
           "[{\"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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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())));
@@ skipping 13 matching lines @@
       "  \"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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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())));
@@ skipping 16 matching lines @@
       "  \"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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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())));
@@ skipping 52 matching lines @@
       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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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())));
@@ skipping 56 matching lines @@
       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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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) {
@@ skipping 12 matching lines @@
       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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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
@@ skipping 88 matching lines @@
           "[{\"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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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.
@@ skipping 18 matching lines @@
   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,
+  ASSERT_TRUE(WaitFor(events::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,
+  ASSERT_TRUE(WaitFor(events::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());
 }