OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <algorithm> | 5 #include <algorithm> |
6 | 6 |
7 #include "base/file_util.h" | 7 #include "base/file_util.h" |
8 #include "base/files/scoped_temp_dir.h" | 8 #include "base/files/scoped_temp_dir.h" |
9 #include "base/json/json_reader.h" | 9 #include "base/json/json_reader.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
55 #include "webkit/common/blob/blob_data.h" | 55 #include "webkit/common/blob/blob_data.h" |
56 | 56 |
57 using content::BrowserContext; | 57 using content::BrowserContext; |
58 using content::BrowserThread; | 58 using content::BrowserThread; |
59 using content::DownloadItem; | 59 using content::DownloadItem; |
60 using content::DownloadManager; | 60 using content::DownloadManager; |
61 using content::URLRequestSlowDownloadJob; | 61 using content::URLRequestSlowDownloadJob; |
62 | 62 |
63 namespace events = extensions::event_names; | 63 namespace events = extensions::event_names; |
64 | 64 |
| 65 namespace errors = download_extension_errors; |
| 66 |
| 67 namespace api = extensions::api::downloads; |
| 68 |
65 namespace { | 69 namespace { |
66 | 70 |
67 // Comparator that orders download items by their ID. Can be used with | 71 // Comparator that orders download items by their ID. Can be used with |
68 // std::sort. | 72 // std::sort. |
69 struct DownloadIdComparator { | 73 struct DownloadIdComparator { |
70 bool operator() (DownloadItem* first, DownloadItem* second) { | 74 bool operator() (DownloadItem* first, DownloadItem* second) { |
71 return first->GetId() < second->GetId(); | 75 return first->GetId() < second->GetId(); |
72 } | 76 } |
73 }; | 77 }; |
74 | 78 |
(...skipping 267 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
342 observer.EnableFileChooser(false); | 346 observer.EnableFileChooser(false); |
343 } | 347 } |
344 current_browser_ = incognito_browser_; | 348 current_browser_ = incognito_browser_; |
345 } | 349 } |
346 | 350 |
347 bool WaitFor(const std::string& event_name, const std::string& json_args) { | 351 bool WaitFor(const std::string& event_name, const std::string& json_args) { |
348 return events_listener_->WaitFor( | 352 return events_listener_->WaitFor( |
349 current_browser()->profile(), event_name, json_args); | 353 current_browser()->profile(), event_name, json_args); |
350 } | 354 } |
351 | 355 |
352 bool WaitForInterruption(DownloadItem* item, int expected_error, | 356 bool WaitForInterruption( |
353 const std::string& on_created_event) { | 357 DownloadItem* item, |
| 358 content::DownloadInterruptReason expected_error, |
| 359 const std::string& on_created_event) { |
354 if (!WaitFor(events::kOnDownloadCreated, on_created_event)) | 360 if (!WaitFor(events::kOnDownloadCreated, on_created_event)) |
355 return false; | 361 return false; |
356 // Now, onCreated is always fired before interruption. | 362 // Now, onCreated is always fired before interruption. |
357 return WaitFor(events::kOnDownloadChanged, | 363 return WaitFor(events::kOnDownloadChanged, |
358 base::StringPrintf("[{\"id\": %d," | 364 base::StringPrintf("[{\"id\": %d," |
359 " \"error\": {\"current\": %d}," | 365 " \"error\": {\"current\": \"%s\"}," |
360 " \"state\": {" | 366 " \"state\": {" |
361 " \"previous\": \"in_progress\"," | 367 " \"previous\": \"in_progress\"," |
362 " \"current\": \"interrupted\"}}]", | 368 " \"current\": \"interrupted\"}}]", |
363 item->GetId(), | 369 item->GetId(), |
364 expected_error)); | 370 content::InterruptReasonDebugString( |
| 371 expected_error).c_str())); |
365 } | 372 } |
366 | 373 |
367 void ClearEvents() { | 374 void ClearEvents() { |
368 events_listener_->ClearEvents(); | 375 events_listener_->ClearEvents(); |
369 } | 376 } |
370 | 377 |
371 std::string GetExtensionURL() { | 378 std::string GetExtensionURL() { |
372 return extension_->url().spec(); | 379 return extension_->url().spec(); |
373 } | 380 } |
374 std::string GetExtensionId() { | 381 std::string GetExtensionId() { |
(...skipping 522 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
897 return item->GetState() == DownloadItem::IN_PROGRESS; | 904 return item->GetState() == DownloadItem::IN_PROGRESS; |
898 } | 905 } |
899 | 906 |
900 DISALLOW_COPY_AND_ASSIGN(JustInProgressDownloadObserver); | 907 DISALLOW_COPY_AND_ASSIGN(JustInProgressDownloadObserver); |
901 }; | 908 }; |
902 | 909 |
903 bool ItemIsInterrupted(DownloadItem* item) { | 910 bool ItemIsInterrupted(DownloadItem* item) { |
904 return item->GetState() == DownloadItem::INTERRUPTED; | 911 return item->GetState() == DownloadItem::INTERRUPTED; |
905 } | 912 } |
906 | 913 |
| 914 content::DownloadInterruptReason InterruptReasonExtensionToContent( |
| 915 api::InterruptReason error) { |
| 916 switch (error) { |
| 917 case api::INTERRUPT_REASON_NONE: |
| 918 return content::DOWNLOAD_INTERRUPT_REASON_NONE; |
| 919 #define INTERRUPT_REASON(name, value) \ |
| 920 case api::INTERRUPT_REASON_##name: \ |
| 921 return content::DOWNLOAD_INTERRUPT_REASON_##name; |
| 922 #include "content/public/browser/download_interrupt_reason_values.h" |
| 923 #undef INTERRUPT_REASON |
| 924 } |
| 925 NOTREACHED(); |
| 926 return content::DOWNLOAD_INTERRUPT_REASON_NONE; |
| 927 } |
| 928 |
| 929 api::InterruptReason InterruptReasonContentToExtension( |
| 930 content::DownloadInterruptReason error) { |
| 931 switch (error) { |
| 932 case content::DOWNLOAD_INTERRUPT_REASON_NONE: |
| 933 return api::INTERRUPT_REASON_NONE; |
| 934 #define INTERRUPT_REASON(name, value) \ |
| 935 case content::DOWNLOAD_INTERRUPT_REASON_##name: \ |
| 936 return api::INTERRUPT_REASON_##name; |
| 937 #include "content/public/browser/download_interrupt_reason_values.h" |
| 938 #undef INTERRUPT_REASON |
| 939 } |
| 940 NOTREACHED(); |
| 941 return api::INTERRUPT_REASON_NONE; |
| 942 } |
| 943 |
907 } // namespace | 944 } // namespace |
908 | 945 |
909 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 946 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
910 DownloadExtensionTest_Open) { | 947 DownloadExtensionTest_Open) { |
911 LoadExtension("downloads_split"); | 948 LoadExtension("downloads_split"); |
912 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 949 EXPECT_STREQ(errors::kInvalidId, |
913 RunFunctionAndReturnError( | 950 RunFunctionAndReturnError( |
914 new DownloadsOpenFunction(), | 951 new DownloadsOpenFunction(), |
915 "[-42]").c_str()); | 952 "[-42]").c_str()); |
916 | 953 |
917 DownloadItem* download_item = CreateSlowTestDownload(); | 954 DownloadItem* download_item = CreateSlowTestDownload(); |
918 ASSERT_TRUE(download_item); | 955 ASSERT_TRUE(download_item); |
919 EXPECT_FALSE(download_item->GetOpened()); | 956 EXPECT_FALSE(download_item->GetOpened()); |
920 EXPECT_FALSE(download_item->GetOpenWhenComplete()); | 957 EXPECT_FALSE(download_item->GetOpenWhenComplete()); |
921 ASSERT_TRUE(WaitFor(events::kOnDownloadCreated, | 958 ASSERT_TRUE(WaitFor(events::kOnDownloadCreated, |
922 base::StringPrintf("[{\"danger\": \"safe\"," | 959 base::StringPrintf("[{\"danger\": \"safe\"," |
923 " \"incognito\": false," | 960 " \"incognito\": false," |
924 " \"mime\": \"application/octet-stream\"," | 961 " \"mime\": \"application/octet-stream\"," |
925 " \"paused\": false," | 962 " \"paused\": false," |
926 " \"url\": \"%s\"}]", | 963 " \"url\": \"%s\"}]", |
927 download_item->GetURL().spec().c_str()))); | 964 download_item->GetURL().spec().c_str()))); |
928 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 965 EXPECT_STREQ(errors::kNotComplete, |
929 RunFunctionAndReturnError( | 966 RunFunctionAndReturnError( |
930 new DownloadsOpenFunction(), | 967 new DownloadsOpenFunction(), |
931 DownloadItemIdAsArgList(download_item)).c_str()); | 968 DownloadItemIdAsArgList(download_item)).c_str()); |
932 | 969 |
933 FinishPendingSlowDownloads(); | 970 FinishPendingSlowDownloads(); |
934 EXPECT_FALSE(download_item->GetOpened()); | 971 EXPECT_FALSE(download_item->GetOpened()); |
935 EXPECT_TRUE(RunFunction(new DownloadsOpenFunction(), | 972 EXPECT_TRUE(RunFunction(new DownloadsOpenFunction(), |
936 DownloadItemIdAsArgList(download_item))); | 973 DownloadItemIdAsArgList(download_item))); |
937 EXPECT_TRUE(download_item->GetOpened()); | 974 EXPECT_TRUE(download_item->GetOpened()); |
938 } | 975 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
971 // And now cancel. | 1008 // And now cancel. |
972 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), | 1009 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), |
973 DownloadItemIdAsArgList(download_item))); | 1010 DownloadItemIdAsArgList(download_item))); |
974 EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState()); | 1011 EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState()); |
975 | 1012 |
976 // Cancel again. Shouldn't have any effect. | 1013 // Cancel again. Shouldn't have any effect. |
977 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), | 1014 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), |
978 DownloadItemIdAsArgList(download_item))); | 1015 DownloadItemIdAsArgList(download_item))); |
979 EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState()); | 1016 EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState()); |
980 | 1017 |
981 // Calling paused on a non-active download yields kInvalidOperationError. | 1018 // Calling paused on a non-active download yields kInvalidId. |
982 std::string error = RunFunctionAndReturnError( | 1019 std::string error = RunFunctionAndReturnError( |
983 new DownloadsPauseFunction(), DownloadItemIdAsArgList(download_item)); | 1020 new DownloadsPauseFunction(), DownloadItemIdAsArgList(download_item)); |
984 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1021 EXPECT_STREQ(errors::kNotInProgress, error.c_str()); |
985 error.c_str()); | |
986 | 1022 |
987 // Calling resume on a non-active download yields kInvalidOperationError | 1023 // Calling resume on a non-active download yields kInvalidId |
988 error = RunFunctionAndReturnError( | 1024 error = RunFunctionAndReturnError( |
989 new DownloadsResumeFunction(), DownloadItemIdAsArgList(download_item)); | 1025 new DownloadsResumeFunction(), DownloadItemIdAsArgList(download_item)); |
990 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1026 EXPECT_STREQ(errors::kNotResumable, error.c_str()); |
991 error.c_str()); | |
992 | 1027 |
993 // Calling paused on a non-existent download yields kInvalidOperationError. | 1028 // Calling paused on a non-existent download yields kInvalidId. |
994 error = RunFunctionAndReturnError( | 1029 error = RunFunctionAndReturnError( |
995 new DownloadsPauseFunction(), "[-42]"); | 1030 new DownloadsPauseFunction(), "[-42]"); |
996 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1031 EXPECT_STREQ(errors::kInvalidId, error.c_str()); |
997 error.c_str()); | |
998 | 1032 |
999 // Calling resume on a non-existent download yields kInvalidOperationError | 1033 // Calling resume on a non-existent download yields kInvalidId |
1000 error = RunFunctionAndReturnError( | 1034 error = RunFunctionAndReturnError( |
1001 new DownloadsResumeFunction(), "[-42]"); | 1035 new DownloadsResumeFunction(), "[-42]"); |
1002 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1036 EXPECT_STREQ(errors::kInvalidId, error.c_str()); |
1003 error.c_str()); | |
1004 | 1037 |
1005 int id = download_item->GetId(); | 1038 int id = download_item->GetId(); |
1006 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( | 1039 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( |
1007 new DownloadsEraseFunction(), | 1040 new DownloadsEraseFunction(), |
1008 base::StringPrintf("[{\"id\": %d}]", id))); | 1041 base::StringPrintf("[{\"id\": %d}]", id))); |
1009 DownloadManager::DownloadVector items; | 1042 DownloadManager::DownloadVector items; |
1010 GetCurrentManager()->GetAllDownloads(&items); | 1043 GetCurrentManager()->GetAllDownloads(&items); |
1011 EXPECT_EQ(0UL, items.size()); | 1044 EXPECT_EQ(0UL, items.size()); |
1012 ASSERT_TRUE(result); | 1045 ASSERT_TRUE(result); |
1013 download_item = NULL; | 1046 download_item = NULL; |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1089 args32, | 1122 args32, |
1090 &result_string)); | 1123 &result_string)); |
1091 | 1124 |
1092 // Simulate an error during icon load by invoking the mock with an empty | 1125 // Simulate an error during icon load by invoking the mock with an empty |
1093 // result string. | 1126 // result string. |
1094 std::string error = RunFunctionAndReturnError( | 1127 std::string error = RunFunctionAndReturnError( |
1095 MockedGetFileIconFunction(download_item->GetTargetFilePath(), | 1128 MockedGetFileIconFunction(download_item->GetTargetFilePath(), |
1096 IconLoader::NORMAL, | 1129 IconLoader::NORMAL, |
1097 std::string()), | 1130 std::string()), |
1098 args32); | 1131 args32); |
1099 EXPECT_STREQ(download_extension_errors::kIconNotFoundError, error.c_str()); | 1132 EXPECT_STREQ(errors::kIconNotFound, error.c_str()); |
1100 | 1133 |
1101 // Once the download item is deleted, we should return kInvalidOperationError. | 1134 // Once the download item is deleted, we should return kInvalidId. |
1102 int id = download_item->GetId(); | 1135 int id = download_item->GetId(); |
1103 download_item->Remove(); | 1136 download_item->Remove(); |
1104 download_item = NULL; | 1137 download_item = NULL; |
1105 EXPECT_EQ(static_cast<DownloadItem*>(NULL), | 1138 EXPECT_EQ(static_cast<DownloadItem*>(NULL), |
1106 GetCurrentManager()->GetDownload(id)); | 1139 GetCurrentManager()->GetDownload(id)); |
1107 error = RunFunctionAndReturnError(new DownloadsGetFileIconFunction(), args32); | 1140 error = RunFunctionAndReturnError(new DownloadsGetFileIconFunction(), args32); |
1108 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1141 EXPECT_STREQ(errors::kInvalidId, |
1109 error.c_str()); | 1142 error.c_str()); |
1110 } | 1143 } |
1111 | 1144 |
1112 // Test that we can acquire file icons for history downloads regardless of | 1145 // Test that we can acquire file icons for history downloads regardless of |
1113 // whether they exist or not. If the file doesn't exist we should receive a | 1146 // whether they exist or not. If the file doesn't exist we should receive a |
1114 // generic icon from the OS/toolkit that may or may not be specific to the file | 1147 // generic icon from the OS/toolkit that may or may not be specific to the file |
1115 // type. | 1148 // type. |
1116 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1149 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1117 DownloadExtensionTest_FileIcon_History) { | 1150 DownloadExtensionTest_FileIcon_History) { |
1118 const HistoryDownloadInfo kHistoryInfo[] = { | 1151 const HistoryDownloadInfo kHistoryInfo[] = { |
(...skipping 20 matching lines...) Expand all Loading... |
1139 ++iter) { | 1172 ++iter) { |
1140 std::string result_string; | 1173 std::string result_string; |
1141 // Use a MockIconExtractorImpl to test if the correct path is being passed | 1174 // Use a MockIconExtractorImpl to test if the correct path is being passed |
1142 // into the DownloadFileIconExtractor. | 1175 // into the DownloadFileIconExtractor. |
1143 EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction( | 1176 EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction( |
1144 (*iter)->GetTargetFilePath(), IconLoader::NORMAL, "hello"), | 1177 (*iter)->GetTargetFilePath(), IconLoader::NORMAL, "hello"), |
1145 base::StringPrintf("[%d, {\"size\": 32}]", (*iter)->GetId()), | 1178 base::StringPrintf("[%d, {\"size\": 32}]", (*iter)->GetId()), |
1146 &result_string)); | 1179 &result_string)); |
1147 EXPECT_STREQ("hello", result_string.c_str()); | 1180 EXPECT_STREQ("hello", result_string.c_str()); |
1148 } | 1181 } |
1149 | |
1150 // The temporary files should be cleaned up when the base::ScopedTempDir is re
moved. | |
1151 } | 1182 } |
1152 | 1183 |
1153 // Test passing the empty query to search(). | 1184 // Test passing the empty query to search(). |
1154 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1185 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1155 DownloadExtensionTest_SearchEmptyQuery) { | 1186 DownloadExtensionTest_SearchEmptyQuery) { |
1156 ScopedCancellingItem item(CreateSlowTestDownload()); | 1187 ScopedCancellingItem item(CreateSlowTestDownload()); |
1157 ASSERT_TRUE(item.get()); | 1188 ASSERT_TRUE(item.get()); |
1158 | 1189 |
1159 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( | 1190 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( |
1160 new DownloadsSearchFunction(), "[{}]")); | 1191 new DownloadsSearchFunction(), "[{}]")); |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1237 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }, | 1268 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }, |
1238 { FILE_PATH_LITERAL("baz"), | 1269 { FILE_PATH_LITERAL("baz"), |
1239 DownloadItem::COMPLETE, | 1270 DownloadItem::COMPLETE, |
1240 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS } | 1271 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS } |
1241 }; | 1272 }; |
1242 DownloadManager::DownloadVector items; | 1273 DownloadManager::DownloadVector items; |
1243 ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo), | 1274 ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo), |
1244 &items)); | 1275 &items)); |
1245 | 1276 |
1246 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( | 1277 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( |
1247 new DownloadsSearchFunction(), "[{\"orderBy\": \"filename\"}]")); | 1278 new DownloadsSearchFunction(), "[{\"orderBy\": [\"filename\"]}]")); |
1248 ASSERT_TRUE(result.get()); | 1279 ASSERT_TRUE(result.get()); |
1249 base::ListValue* result_list = NULL; | 1280 base::ListValue* result_list = NULL; |
1250 ASSERT_TRUE(result->GetAsList(&result_list)); | 1281 ASSERT_TRUE(result->GetAsList(&result_list)); |
1251 ASSERT_EQ(2UL, result_list->GetSize()); | 1282 ASSERT_EQ(2UL, result_list->GetSize()); |
1252 base::DictionaryValue* item0_value = NULL; | 1283 base::DictionaryValue* item0_value = NULL; |
1253 base::DictionaryValue* item1_value = NULL; | 1284 base::DictionaryValue* item1_value = NULL; |
1254 ASSERT_TRUE(result_list->GetDictionary(0, &item0_value)); | 1285 ASSERT_TRUE(result_list->GetDictionary(0, &item0_value)); |
1255 ASSERT_TRUE(result_list->GetDictionary(1, &item1_value)); | 1286 ASSERT_TRUE(result_list->GetDictionary(1, &item1_value)); |
1256 std::string item0_name, item1_name; | 1287 std::string item0_name, item1_name; |
1257 ASSERT_TRUE(item0_value->GetString("filename", &item0_name)); | 1288 ASSERT_TRUE(item0_value->GetString("filename", &item0_name)); |
(...skipping 12 matching lines...) Expand all Loading... |
1270 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }, | 1301 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }, |
1271 { FILE_PATH_LITERAL("baz"), | 1302 { FILE_PATH_LITERAL("baz"), |
1272 DownloadItem::COMPLETE, | 1303 DownloadItem::COMPLETE, |
1273 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS } | 1304 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS } |
1274 }; | 1305 }; |
1275 DownloadManager::DownloadVector items; | 1306 DownloadManager::DownloadVector items; |
1276 ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo), | 1307 ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo), |
1277 &items)); | 1308 &items)); |
1278 | 1309 |
1279 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( | 1310 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( |
1280 new DownloadsSearchFunction(), "[{\"orderBy\": \"\"}]")); | 1311 new DownloadsSearchFunction(), "[{\"orderBy\": []}]")); |
1281 ASSERT_TRUE(result.get()); | 1312 ASSERT_TRUE(result.get()); |
1282 base::ListValue* result_list = NULL; | 1313 base::ListValue* result_list = NULL; |
1283 ASSERT_TRUE(result->GetAsList(&result_list)); | 1314 ASSERT_TRUE(result->GetAsList(&result_list)); |
1284 ASSERT_EQ(2UL, result_list->GetSize()); | 1315 ASSERT_EQ(2UL, result_list->GetSize()); |
1285 base::DictionaryValue* item0_value = NULL; | 1316 base::DictionaryValue* item0_value = NULL; |
1286 base::DictionaryValue* item1_value = NULL; | 1317 base::DictionaryValue* item1_value = NULL; |
1287 ASSERT_TRUE(result_list->GetDictionary(0, &item0_value)); | 1318 ASSERT_TRUE(result_list->GetDictionary(0, &item0_value)); |
1288 ASSERT_TRUE(result_list->GetDictionary(1, &item1_value)); | 1319 ASSERT_TRUE(result_list->GetDictionary(1, &item1_value)); |
1289 std::string item0_name, item1_name; | 1320 std::string item0_name, item1_name; |
1290 ASSERT_TRUE(item0_value->GetString("filename", &item0_name)); | 1321 ASSERT_TRUE(item0_value->GetString("filename", &item0_name)); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1347 base::ListValue* result_list = NULL; | 1378 base::ListValue* result_list = NULL; |
1348 ASSERT_TRUE(result->GetAsList(&result_list)); | 1379 ASSERT_TRUE(result->GetAsList(&result_list)); |
1349 ASSERT_EQ(1UL, result_list->GetSize()); | 1380 ASSERT_EQ(1UL, result_list->GetSize()); |
1350 } | 1381 } |
1351 | 1382 |
1352 // Test invalid search parameters. | 1383 // Test invalid search parameters. |
1353 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1384 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1354 DownloadExtensionTest_SearchInvalid) { | 1385 DownloadExtensionTest_SearchInvalid) { |
1355 std::string error = RunFunctionAndReturnError( | 1386 std::string error = RunFunctionAndReturnError( |
1356 new DownloadsSearchFunction(), "[{\"filenameRegex\": \"(\"}]"); | 1387 new DownloadsSearchFunction(), "[{\"filenameRegex\": \"(\"}]"); |
1357 EXPECT_STREQ(download_extension_errors::kInvalidFilterError, | 1388 EXPECT_STREQ(errors::kInvalidFilter, |
1358 error.c_str()); | 1389 error.c_str()); |
1359 error = RunFunctionAndReturnError( | 1390 error = RunFunctionAndReturnError( |
1360 new DownloadsSearchFunction(), "[{\"orderBy\": \"goat\"}]"); | 1391 new DownloadsSearchFunction(), "[{\"orderBy\": [\"goat\"]}]"); |
1361 EXPECT_STREQ(download_extension_errors::kInvalidOrderByError, | 1392 EXPECT_STREQ(errors::kInvalidOrderBy, |
1362 error.c_str()); | 1393 error.c_str()); |
1363 error = RunFunctionAndReturnError( | 1394 error = RunFunctionAndReturnError( |
1364 new DownloadsSearchFunction(), "[{\"limit\": -1}]"); | 1395 new DownloadsSearchFunction(), "[{\"limit\": -1}]"); |
1365 EXPECT_STREQ(download_extension_errors::kInvalidQueryLimit, | 1396 EXPECT_STREQ(errors::kInvalidQueryLimit, |
1366 error.c_str()); | 1397 error.c_str()); |
1367 } | 1398 } |
1368 | 1399 |
1369 // Test searching using multiple conditions through multiple downloads. | 1400 // Test searching using multiple conditions through multiple downloads. |
1370 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1401 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1371 DownloadExtensionTest_SearchPlural) { | 1402 DownloadExtensionTest_SearchPlural) { |
1372 const HistoryDownloadInfo kHistoryInfo[] = { | 1403 const HistoryDownloadInfo kHistoryInfo[] = { |
1373 { FILE_PATH_LITERAL("aaa"), | 1404 { FILE_PATH_LITERAL("aaa"), |
1374 DownloadItem::CANCELLED, | 1405 DownloadItem::CANCELLED, |
1375 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }, | 1406 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS }, |
1376 { FILE_PATH_LITERAL("zzz"), | 1407 { FILE_PATH_LITERAL("zzz"), |
1377 DownloadItem::COMPLETE, | 1408 DownloadItem::COMPLETE, |
1378 content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT }, | 1409 content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT }, |
1379 { FILE_PATH_LITERAL("baz"), | 1410 { FILE_PATH_LITERAL("baz"), |
1380 DownloadItem::COMPLETE, | 1411 DownloadItem::COMPLETE, |
1381 content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT }, | 1412 content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT }, |
1382 }; | 1413 }; |
1383 DownloadManager::DownloadVector items; | 1414 DownloadManager::DownloadVector items; |
1384 ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo), | 1415 ASSERT_TRUE(CreateHistoryDownloads(kHistoryInfo, arraysize(kHistoryInfo), |
1385 &items)); | 1416 &items)); |
1386 | 1417 |
1387 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( | 1418 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( |
1388 new DownloadsSearchFunction(), "[{" | 1419 new DownloadsSearchFunction(), "[{" |
1389 "\"state\": \"complete\", " | 1420 "\"state\": \"complete\", " |
1390 "\"danger\": \"content\", " | 1421 "\"danger\": \"content\", " |
1391 "\"orderBy\": \"filename\", " | 1422 "\"orderBy\": [\"filename\"], " |
1392 "\"limit\": 1}]")); | 1423 "\"limit\": 1}]")); |
1393 ASSERT_TRUE(result.get()); | 1424 ASSERT_TRUE(result.get()); |
1394 base::ListValue* result_list = NULL; | 1425 base::ListValue* result_list = NULL; |
1395 ASSERT_TRUE(result->GetAsList(&result_list)); | 1426 ASSERT_TRUE(result->GetAsList(&result_list)); |
1396 ASSERT_EQ(1UL, result_list->GetSize()); | 1427 ASSERT_EQ(1UL, result_list->GetSize()); |
1397 base::DictionaryValue* item_value = NULL; | 1428 base::DictionaryValue* item_value = NULL; |
1398 ASSERT_TRUE(result_list->GetDictionary(0, &item_value)); | 1429 ASSERT_TRUE(result_list->GetDictionary(0, &item_value)); |
1399 base::FilePath::StringType item_name; | 1430 base::FilePath::StringType item_name; |
1400 ASSERT_TRUE(item_value->GetString("filename", &item_name)); | 1431 ASSERT_TRUE(item_value->GetString("filename", &item_name)); |
1401 ASSERT_EQ(items[2]->GetTargetFilePath().value(), item_name); | 1432 ASSERT_EQ(items[2]->GetTargetFilePath().value(), item_name); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1461 ASSERT_EQ(1UL, result_list->GetSize()); | 1492 ASSERT_EQ(1UL, result_list->GetSize()); |
1462 ASSERT_TRUE(result_list->GetDictionary(0, &result_dict)); | 1493 ASSERT_TRUE(result_list->GetDictionary(0, &result_dict)); |
1463 ASSERT_TRUE(result_dict->GetString("filename", &filename)); | 1494 ASSERT_TRUE(result_dict->GetString("filename", &filename)); |
1464 EXPECT_TRUE(on_item->GetTargetFilePath() == base::FilePath(filename)); | 1495 EXPECT_TRUE(on_item->GetTargetFilePath() == base::FilePath(filename)); |
1465 ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito)); | 1496 ASSERT_TRUE(result_dict->GetBoolean("incognito", &is_incognito)); |
1466 EXPECT_FALSE(is_incognito); | 1497 EXPECT_FALSE(is_incognito); |
1467 | 1498 |
1468 // Pausing/Resuming the off-record item while on the record should return an | 1499 // Pausing/Resuming the off-record item while on the record should return an |
1469 // error. Cancelling "non-existent" downloads is not an error. | 1500 // error. Cancelling "non-existent" downloads is not an error. |
1470 error = RunFunctionAndReturnError(new DownloadsPauseFunction(), off_item_arg); | 1501 error = RunFunctionAndReturnError(new DownloadsPauseFunction(), off_item_arg); |
1471 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1502 EXPECT_STREQ(errors::kInvalidId, |
1472 error.c_str()); | 1503 error.c_str()); |
1473 error = RunFunctionAndReturnError(new DownloadsResumeFunction(), | 1504 error = RunFunctionAndReturnError(new DownloadsResumeFunction(), |
1474 off_item_arg); | 1505 off_item_arg); |
1475 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1506 EXPECT_STREQ(errors::kInvalidId, |
1476 error.c_str()); | 1507 error.c_str()); |
1477 error = RunFunctionAndReturnError( | 1508 error = RunFunctionAndReturnError( |
1478 new DownloadsGetFileIconFunction(), | 1509 new DownloadsGetFileIconFunction(), |
1479 base::StringPrintf("[%d, {}]", off_item->GetId())); | 1510 base::StringPrintf("[%d, {}]", off_item->GetId())); |
1480 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1511 EXPECT_STREQ(errors::kInvalidId, |
1481 error.c_str()); | 1512 error.c_str()); |
1482 | 1513 |
1483 GoOffTheRecord(); | 1514 GoOffTheRecord(); |
1484 | 1515 |
1485 // Do the FileIcon test for both the on- and off-items while off the record. | 1516 // Do the FileIcon test for both the on- and off-items while off the record. |
1486 // NOTE(benjhayden): This does not include the FileIcon test from history, | 1517 // NOTE(benjhayden): This does not include the FileIcon test from history, |
1487 // just active downloads. This shouldn't be a problem. | 1518 // just active downloads. This shouldn't be a problem. |
1488 EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction( | 1519 EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction( |
1489 on_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"), | 1520 on_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"), |
1490 base::StringPrintf("[%d, {}]", on_item->GetId()), &result_string)); | 1521 base::StringPrintf("[%d, {}]", on_item->GetId()), &result_string)); |
(...skipping 11 matching lines...) Expand all Loading... |
1502 EXPECT_FALSE(on_item->IsPaused()); | 1533 EXPECT_FALSE(on_item->IsPaused()); |
1503 EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), on_item_arg)); | 1534 EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), on_item_arg)); |
1504 EXPECT_FALSE(on_item->IsPaused()); | 1535 EXPECT_FALSE(on_item->IsPaused()); |
1505 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), on_item_arg)); | 1536 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), on_item_arg)); |
1506 EXPECT_TRUE(on_item->IsPaused()); | 1537 EXPECT_TRUE(on_item->IsPaused()); |
1507 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), on_item_arg)); | 1538 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), on_item_arg)); |
1508 EXPECT_EQ(DownloadItem::CANCELLED, on_item->GetState()); | 1539 EXPECT_EQ(DownloadItem::CANCELLED, on_item->GetState()); |
1509 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), on_item_arg)); | 1540 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), on_item_arg)); |
1510 EXPECT_EQ(DownloadItem::CANCELLED, on_item->GetState()); | 1541 EXPECT_EQ(DownloadItem::CANCELLED, on_item->GetState()); |
1511 error = RunFunctionAndReturnError(new DownloadsPauseFunction(), on_item_arg); | 1542 error = RunFunctionAndReturnError(new DownloadsPauseFunction(), on_item_arg); |
1512 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1543 EXPECT_STREQ(errors::kNotInProgress, error.c_str()); |
1513 error.c_str()); | |
1514 error = RunFunctionAndReturnError(new DownloadsResumeFunction(), on_item_arg); | 1544 error = RunFunctionAndReturnError(new DownloadsResumeFunction(), on_item_arg); |
1515 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1545 EXPECT_STREQ(errors::kNotResumable, error.c_str()); |
1516 error.c_str()); | |
1517 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg)); | 1546 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg)); |
1518 EXPECT_TRUE(off_item->IsPaused()); | 1547 EXPECT_TRUE(off_item->IsPaused()); |
1519 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg)); | 1548 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg)); |
1520 EXPECT_TRUE(off_item->IsPaused()); | 1549 EXPECT_TRUE(off_item->IsPaused()); |
1521 EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), off_item_arg)); | 1550 EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), off_item_arg)); |
1522 EXPECT_FALSE(off_item->IsPaused()); | 1551 EXPECT_FALSE(off_item->IsPaused()); |
1523 EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), off_item_arg)); | 1552 EXPECT_TRUE(RunFunction(new DownloadsResumeFunction(), off_item_arg)); |
1524 EXPECT_FALSE(off_item->IsPaused()); | 1553 EXPECT_FALSE(off_item->IsPaused()); |
1525 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg)); | 1554 EXPECT_TRUE(RunFunction(new DownloadsPauseFunction(), off_item_arg)); |
1526 EXPECT_TRUE(off_item->IsPaused()); | 1555 EXPECT_TRUE(off_item->IsPaused()); |
1527 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), off_item_arg)); | 1556 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), off_item_arg)); |
1528 EXPECT_EQ(DownloadItem::CANCELLED, off_item->GetState()); | 1557 EXPECT_EQ(DownloadItem::CANCELLED, off_item->GetState()); |
1529 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), off_item_arg)); | 1558 EXPECT_TRUE(RunFunction(new DownloadsCancelFunction(), off_item_arg)); |
1530 EXPECT_EQ(DownloadItem::CANCELLED, off_item->GetState()); | 1559 EXPECT_EQ(DownloadItem::CANCELLED, off_item->GetState()); |
1531 error = RunFunctionAndReturnError(new DownloadsPauseFunction(), | 1560 error = RunFunctionAndReturnError(new DownloadsPauseFunction(), off_item_arg); |
1532 off_item_arg); | 1561 EXPECT_STREQ(errors::kNotInProgress, error.c_str()); |
1533 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | |
1534 error.c_str()); | |
1535 error = RunFunctionAndReturnError(new DownloadsResumeFunction(), | 1562 error = RunFunctionAndReturnError(new DownloadsResumeFunction(), |
1536 off_item_arg); | 1563 off_item_arg); |
1537 EXPECT_STREQ(download_extension_errors::kInvalidOperationError, | 1564 EXPECT_STREQ(errors::kNotResumable, error.c_str()); |
1538 error.c_str()); | |
1539 } | 1565 } |
1540 | 1566 |
1541 // Test that we can start a download and that the correct sequence of events is | 1567 // Test that we can start a download and that the correct sequence of events is |
1542 // fired for it. | 1568 // fired for it. |
1543 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1569 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1544 DownloadExtensionTest_Download_Basic) { | 1570 DownloadExtensionTest_Download_Basic) { |
1545 LoadExtension("downloads_split"); | 1571 LoadExtension("downloads_split"); |
1546 ASSERT_TRUE(StartEmbeddedTestServer()); | 1572 ASSERT_TRUE(StartEmbeddedTestServer()); |
1547 ASSERT_TRUE(test_server()->Start()); | 1573 ASSERT_TRUE(test_server()->Start()); |
1548 std::string download_url = test_server()->GetURL("slow?0").spec(); | 1574 std::string download_url = test_server()->GetURL("slow?0").spec(); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1666 "sEc-", | 1692 "sEc-", |
1667 "pRoxY-probably-not-evil", | 1693 "pRoxY-probably-not-evil", |
1668 "sEc-probably-not-evil", | 1694 "sEc-probably-not-evil", |
1669 "oRiGiN", | 1695 "oRiGiN", |
1670 "Access-Control-Request-Headers", | 1696 "Access-Control-Request-Headers", |
1671 "Access-Control-Request-Method", | 1697 "Access-Control-Request-Method", |
1672 }; | 1698 }; |
1673 | 1699 |
1674 for (size_t index = 0; index < arraysize(kUnsafeHeaders); ++index) { | 1700 for (size_t index = 0; index < arraysize(kUnsafeHeaders); ++index) { |
1675 std::string download_url = test_server()->GetURL("slow?0").spec(); | 1701 std::string download_url = test_server()->GetURL("slow?0").spec(); |
1676 EXPECT_STREQ(download_extension_errors::kGenericError, | 1702 EXPECT_STREQ(errors::kInvalidHeader, |
1677 RunFunctionAndReturnError(new DownloadsDownloadFunction(), | 1703 RunFunctionAndReturnError(new DownloadsDownloadFunction(), |
1678 base::StringPrintf( | 1704 base::StringPrintf( |
1679 "[{\"url\": \"%s\"," | 1705 "[{\"url\": \"%s\"," |
1680 " \"filename\": \"unsafe-header-%d.txt\"," | 1706 " \"filename\": \"unsafe-header-%d.txt\"," |
1681 " \"headers\": [{" | 1707 " \"headers\": [{" |
1682 " \"name\": \"%s\"," | 1708 " \"name\": \"%s\"," |
1683 " \"value\": \"unsafe\"}]}]", | 1709 " \"value\": \"unsafe\"}]}]", |
1684 download_url.c_str(), | 1710 download_url.c_str(), |
1685 static_cast<int>(index), | 1711 static_cast<int>(index), |
1686 kUnsafeHeaders[index])).c_str()); | 1712 kUnsafeHeaders[index])).c_str()); |
1687 } | 1713 } |
1688 } | 1714 } |
1689 | 1715 |
1690 // Test that subdirectories (slashes) are disallowed in filenames. | |
1691 // TODO(benjhayden) Update this when subdirectories are supported. | |
1692 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1716 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1693 DownloadExtensionTest_Download_Subdirectory) { | 1717 DownloadExtensionTest_Download_Subdirectory) { |
1694 LoadExtension("downloads_split"); | 1718 LoadExtension("downloads_split"); |
1695 ASSERT_TRUE(StartEmbeddedTestServer()); | 1719 ASSERT_TRUE(StartEmbeddedTestServer()); |
1696 ASSERT_TRUE(test_server()->Start()); | 1720 ASSERT_TRUE(test_server()->Start()); |
1697 std::string download_url = test_server()->GetURL("slow?0").spec(); | 1721 std::string download_url = test_server()->GetURL("slow?0").spec(); |
1698 GoOnTheRecord(); | 1722 GoOnTheRecord(); |
1699 | 1723 |
1700 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, | 1724 scoped_ptr<base::Value> result(RunFunctionAndReturnResult( |
1701 RunFunctionAndReturnError(new DownloadsDownloadFunction(), | 1725 new DownloadsDownloadFunction(), base::StringPrintf( |
1702 base::StringPrintf( | 1726 "[{\"url\": \"%s\"," |
1703 "[{\"url\": \"%s\"," | 1727 " \"filename\": \"sub/dir/ect/ory.txt\"}]", |
1704 " \"filename\": \"sub/dir/ect/ory.txt\"}]", | 1728 download_url.c_str()))); |
1705 download_url.c_str())).c_str()); | 1729 ASSERT_TRUE(result.get()); |
| 1730 int result_id = -1; |
| 1731 ASSERT_TRUE(result->GetAsInteger(&result_id)); |
| 1732 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); |
| 1733 ASSERT_TRUE(item); |
| 1734 ScopedCancellingItem canceller(item); |
| 1735 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); |
| 1736 |
| 1737 ASSERT_TRUE(WaitFor(events::kOnDownloadCreated, |
| 1738 base::StringPrintf("[{\"danger\": \"safe\"," |
| 1739 " \"incognito\": false," |
| 1740 " \"mime\": \"text/plain\"," |
| 1741 " \"paused\": false," |
| 1742 " \"url\": \"%s\"}]", |
| 1743 download_url.c_str()))); |
| 1744 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
| 1745 base::StringPrintf("[{\"id\": %d," |
| 1746 " \"filename\": {" |
| 1747 " \"previous\": \"\"," |
| 1748 " \"current\": \"%s\"}}]", |
| 1749 result_id, |
| 1750 GetFilename("sub/dir/ect/ory.txt").c_str()))); |
| 1751 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
| 1752 base::StringPrintf("[{\"id\": %d," |
| 1753 " \"state\": {" |
| 1754 " \"previous\": \"in_progress\"," |
| 1755 " \"current\": \"complete\"}}]", |
| 1756 result_id))); |
1706 } | 1757 } |
1707 | 1758 |
1708 // Test that invalid filenames are disallowed. | 1759 // Test that invalid filenames are disallowed. |
1709 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1760 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1710 DownloadExtensionTest_Download_InvalidFilename) { | 1761 DownloadExtensionTest_Download_InvalidFilename) { |
1711 LoadExtension("downloads_split"); | 1762 LoadExtension("downloads_split"); |
1712 ASSERT_TRUE(StartEmbeddedTestServer()); | 1763 ASSERT_TRUE(StartEmbeddedTestServer()); |
1713 ASSERT_TRUE(test_server()->Start()); | 1764 ASSERT_TRUE(test_server()->Start()); |
1714 std::string download_url = test_server()->GetURL("slow?0").spec(); | 1765 std::string download_url = test_server()->GetURL("slow?0").spec(); |
1715 GoOnTheRecord(); | 1766 GoOnTheRecord(); |
1716 | 1767 |
1717 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, | 1768 EXPECT_STREQ(errors::kInvalidFilename, |
1718 RunFunctionAndReturnError(new DownloadsDownloadFunction(), | 1769 RunFunctionAndReturnError(new DownloadsDownloadFunction(), |
1719 base::StringPrintf( | 1770 base::StringPrintf( |
1720 "[{\"url\": \"%s\"," | 1771 "[{\"url\": \"%s\"," |
1721 " \"filename\": \"../../../../../etc/passwd\"}]", | 1772 " \"filename\": \"../../../../../etc/passwd\"}]", |
1722 download_url.c_str())).c_str()); | 1773 download_url.c_str())).c_str()); |
1723 } | 1774 } |
1724 | 1775 |
1725 // Test that downloading invalid URLs immediately returns kInvalidURLError. | 1776 // Test that downloading invalid URLs immediately returns kInvalidURLError. |
1726 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1777 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1727 DownloadExtensionTest_Download_InvalidURLs) { | 1778 DownloadExtensionTest_Download_InvalidURLs) { |
1728 LoadExtension("downloads_split"); | 1779 LoadExtension("downloads_split"); |
1729 GoOnTheRecord(); | 1780 GoOnTheRecord(); |
1730 | 1781 |
1731 static const char* kInvalidURLs[] = { | 1782 static const char* kInvalidURLs[] = { |
1732 "foo bar", | 1783 "foo bar", |
1733 "../hello", | 1784 "../hello", |
1734 "/hello", | 1785 "/hello", |
1735 "google.com/", | |
1736 "http://", | 1786 "http://", |
1737 "#frag", | 1787 "#frag", |
1738 "foo/bar.html#frag", | 1788 "foo/bar.html#frag", |
| 1789 "google.com/", |
1739 }; | 1790 }; |
1740 | 1791 |
1741 for (size_t index = 0; index < arraysize(kInvalidURLs); ++index) { | 1792 for (size_t index = 0; index < arraysize(kInvalidURLs); ++index) { |
1742 EXPECT_STREQ(download_extension_errors::kInvalidURLError, | 1793 EXPECT_STREQ(errors::kInvalidURL, |
1743 RunFunctionAndReturnError(new DownloadsDownloadFunction(), | 1794 RunFunctionAndReturnError(new DownloadsDownloadFunction(), |
1744 base::StringPrintf( | 1795 base::StringPrintf( |
1745 "[{\"url\": \"%s\"}]", kInvalidURLs[index])).c_str()) | 1796 "[{\"url\": \"%s\"}]", kInvalidURLs[index])).c_str()) |
1746 << kInvalidURLs[index]; | 1797 << kInvalidURLs[index]; |
1747 } | 1798 } |
1748 | 1799 |
1749 EXPECT_STREQ("net::ERR_ACCESS_DENIED", RunFunctionAndReturnError( | 1800 EXPECT_STREQ("net::ERR_ACCESS_DENIED", RunFunctionAndReturnError( |
1750 new DownloadsDownloadFunction(), | 1801 new DownloadsDownloadFunction(), |
1751 "[{\"url\": \"javascript:document.write(\\\"hello\\\");\"}]").c_str()); | 1802 "[{\"url\": \"javascript:document.write(\\\"hello\\\");\"}]").c_str()); |
1752 EXPECT_STREQ("net::ERR_ACCESS_DENIED", RunFunctionAndReturnError( | 1803 EXPECT_STREQ("net::ERR_ACCESS_DENIED", RunFunctionAndReturnError( |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1913 " \"filename\": \"auth-basic-fail.txt\"}]", | 1964 " \"filename\": \"auth-basic-fail.txt\"}]", |
1914 download_url.c_str()))); | 1965 download_url.c_str()))); |
1915 ASSERT_TRUE(result.get()); | 1966 ASSERT_TRUE(result.get()); |
1916 int result_id = -1; | 1967 int result_id = -1; |
1917 ASSERT_TRUE(result->GetAsInteger(&result_id)); | 1968 ASSERT_TRUE(result->GetAsInteger(&result_id)); |
1918 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); | 1969 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); |
1919 ASSERT_TRUE(item); | 1970 ASSERT_TRUE(item); |
1920 ScopedCancellingItem canceller(item); | 1971 ScopedCancellingItem canceller(item); |
1921 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); | 1972 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); |
1922 | 1973 |
1923 ASSERT_TRUE(WaitForInterruption(item, 30, base::StringPrintf( | 1974 ASSERT_TRUE(WaitForInterruption( |
1924 "[{\"danger\": \"safe\"," | 1975 item, |
1925 " \"incognito\": false," | 1976 content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED, |
1926 " \"mime\": \"text/html\"," | 1977 base::StringPrintf("[{\"danger\": \"safe\"," |
1927 " \"paused\": false," | 1978 " \"incognito\": false," |
1928 " \"url\": \"%s\"}]", | 1979 " \"mime\": \"text/html\"," |
1929 download_url.c_str()))); | 1980 " \"paused\": false," |
| 1981 " \"url\": \"%s\"}]", |
| 1982 download_url.c_str()))); |
1930 } | 1983 } |
1931 | 1984 |
1932 // Test that DownloadsDownloadFunction propagates |headers| to the URLRequest. | 1985 // Test that DownloadsDownloadFunction propagates |headers| to the URLRequest. |
1933 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 1986 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
1934 DownloadExtensionTest_Download_Headers) { | 1987 DownloadExtensionTest_Download_Headers) { |
1935 LoadExtension("downloads_split"); | 1988 LoadExtension("downloads_split"); |
1936 ASSERT_TRUE(StartEmbeddedTestServer()); | 1989 ASSERT_TRUE(StartEmbeddedTestServer()); |
1937 ASSERT_TRUE(test_server()->Start()); | 1990 ASSERT_TRUE(test_server()->Start()); |
1938 std::string download_url = test_server()->GetURL("files/downloads/" | 1991 std::string download_url = test_server()->GetURL("files/downloads/" |
1939 "a_zip_file.zip?expected_headers=Foo:bar&expected_headers=Qx:yo").spec(); | 1992 "a_zip_file.zip?expected_headers=Foo:bar&expected_headers=Qx:yo").spec(); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1996 " \"filename\": \"headers-fail.txt\"}]", | 2049 " \"filename\": \"headers-fail.txt\"}]", |
1997 download_url.c_str()))); | 2050 download_url.c_str()))); |
1998 ASSERT_TRUE(result.get()); | 2051 ASSERT_TRUE(result.get()); |
1999 int result_id = -1; | 2052 int result_id = -1; |
2000 ASSERT_TRUE(result->GetAsInteger(&result_id)); | 2053 ASSERT_TRUE(result->GetAsInteger(&result_id)); |
2001 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); | 2054 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); |
2002 ASSERT_TRUE(item); | 2055 ASSERT_TRUE(item); |
2003 ScopedCancellingItem canceller(item); | 2056 ScopedCancellingItem canceller(item); |
2004 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); | 2057 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); |
2005 | 2058 |
2006 ASSERT_TRUE(WaitForInterruption(item, 33, base::StringPrintf( | 2059 ASSERT_TRUE(WaitForInterruption( |
2007 "[{\"danger\": \"safe\"," | 2060 item, |
2008 " \"incognito\": false," | 2061 content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT, |
2009 " \"bytesReceived\": 0," | 2062 base::StringPrintf("[{\"danger\": \"safe\"," |
2010 " \"mime\": \"\"," | 2063 " \"incognito\": false," |
2011 " \"paused\": false," | 2064 " \"bytesReceived\": 0," |
2012 " \"url\": \"%s\"}]", | 2065 " \"mime\": \"\"," |
2013 download_url.c_str()))); | 2066 " \"paused\": false," |
| 2067 " \"url\": \"%s\"}]", |
| 2068 download_url.c_str()))); |
2014 } | 2069 } |
2015 | 2070 |
2016 // Test that DownloadsDownloadFunction propagates the Authorization header | 2071 // Test that DownloadsDownloadFunction propagates the Authorization header |
2017 // correctly. | 2072 // correctly. |
2018 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 2073 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
2019 DownloadExtensionTest_Download_AuthBasic) { | 2074 DownloadExtensionTest_Download_AuthBasic) { |
2020 LoadExtension("downloads_split"); | 2075 LoadExtension("downloads_split"); |
2021 ASSERT_TRUE(StartEmbeddedTestServer()); | 2076 ASSERT_TRUE(StartEmbeddedTestServer()); |
2022 ASSERT_TRUE(test_server()->Start()); | 2077 ASSERT_TRUE(test_server()->Start()); |
2023 std::string download_url = test_server()->GetURL("auth-basic").spec(); | 2078 std::string download_url = test_server()->GetURL("auth-basic").spec(); |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2122 " \"filename\": \"post-get.txt\"}]", | 2177 " \"filename\": \"post-get.txt\"}]", |
2123 download_url.c_str()))); | 2178 download_url.c_str()))); |
2124 ASSERT_TRUE(result.get()); | 2179 ASSERT_TRUE(result.get()); |
2125 int result_id = -1; | 2180 int result_id = -1; |
2126 ASSERT_TRUE(result->GetAsInteger(&result_id)); | 2181 ASSERT_TRUE(result->GetAsInteger(&result_id)); |
2127 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); | 2182 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); |
2128 ASSERT_TRUE(item); | 2183 ASSERT_TRUE(item); |
2129 ScopedCancellingItem canceller(item); | 2184 ScopedCancellingItem canceller(item); |
2130 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); | 2185 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); |
2131 | 2186 |
2132 ASSERT_TRUE(WaitForInterruption(item, 33, base::StringPrintf( | 2187 ASSERT_TRUE(WaitForInterruption( |
2133 "[{\"danger\": \"safe\"," | 2188 item, |
2134 " \"incognito\": false," | 2189 content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT, |
2135 " \"mime\": \"\"," | 2190 base::StringPrintf("[{\"danger\": \"safe\"," |
2136 " \"paused\": false," | 2191 " \"incognito\": false," |
2137 " \"id\": %d," | 2192 " \"mime\": \"\"," |
2138 " \"url\": \"%s\"}]", | 2193 " \"paused\": false," |
2139 result_id, | 2194 " \"id\": %d," |
2140 download_url.c_str()))); | 2195 " \"url\": \"%s\"}]", |
| 2196 result_id, |
| 2197 download_url.c_str()))); |
2141 } | 2198 } |
2142 | 2199 |
2143 // Test that downloadPostSuccess would fail if the resource requires the POST | 2200 // Test that downloadPostSuccess would fail if the resource requires the POST |
2144 // method, and chrome fails to propagate the |body| parameter back to the | 2201 // method, and chrome fails to propagate the |body| parameter back to the |
2145 // server. This tests both that testserver.py does not succeed when it should | 2202 // server. This tests both that testserver.py does not succeed when it should |
2146 // fail, and this tests how the downloads extension api exposes the failure to | 2203 // fail, and this tests how the downloads extension api exposes the failure to |
2147 // extensions. | 2204 // extensions. |
2148 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 2205 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
2149 DownloadExtensionTest_Download_Post_NoBody) { | 2206 DownloadExtensionTest_Download_Post_NoBody) { |
2150 LoadExtension("downloads_split"); | 2207 LoadExtension("downloads_split"); |
(...skipping 10 matching lines...) Expand all Loading... |
2161 " \"filename\": \"post-nobody.txt\"}]", | 2218 " \"filename\": \"post-nobody.txt\"}]", |
2162 download_url.c_str()))); | 2219 download_url.c_str()))); |
2163 ASSERT_TRUE(result.get()); | 2220 ASSERT_TRUE(result.get()); |
2164 int result_id = -1; | 2221 int result_id = -1; |
2165 ASSERT_TRUE(result->GetAsInteger(&result_id)); | 2222 ASSERT_TRUE(result->GetAsInteger(&result_id)); |
2166 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); | 2223 DownloadItem* item = GetCurrentManager()->GetDownload(result_id); |
2167 ASSERT_TRUE(item); | 2224 ASSERT_TRUE(item); |
2168 ScopedCancellingItem canceller(item); | 2225 ScopedCancellingItem canceller(item); |
2169 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); | 2226 ASSERT_EQ(download_url, item->GetOriginalUrl().spec()); |
2170 | 2227 |
2171 ASSERT_TRUE(WaitForInterruption(item, 33, base::StringPrintf( | 2228 ASSERT_TRUE(WaitForInterruption( |
2172 "[{\"danger\": \"safe\"," | 2229 item, |
2173 " \"incognito\": false," | 2230 content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT, |
2174 " \"mime\": \"\"," | 2231 base::StringPrintf("[{\"danger\": \"safe\"," |
2175 " \"paused\": false," | 2232 " \"incognito\": false," |
2176 " \"id\": %d," | 2233 " \"mime\": \"\"," |
2177 " \"url\": \"%s\"}]", | 2234 " \"paused\": false," |
2178 result_id, | 2235 " \"id\": %d," |
2179 download_url.c_str()))); | 2236 " \"url\": \"%s\"}]", |
| 2237 result_id, |
| 2238 download_url.c_str()))); |
2180 } | 2239 } |
2181 | 2240 |
2182 // Test that cancel()ing an in-progress download causes its state to transition | 2241 // Test that cancel()ing an in-progress download causes its state to transition |
2183 // to interrupted, and test that that state transition is detectable by an | 2242 // to interrupted, and test that that state transition is detectable by an |
2184 // onChanged event listener. TODO(benjhayden): Test other sources of | 2243 // onChanged event listener. TODO(benjhayden): Test other sources of |
2185 // interruptions such as server death. | 2244 // interruptions such as server death. |
2186 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 2245 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
2187 DownloadExtensionTest_Download_Cancel) { | 2246 DownloadExtensionTest_Download_Cancel) { |
2188 LoadExtension("downloads_split"); | 2247 LoadExtension("downloads_split"); |
2189 ASSERT_TRUE(StartEmbeddedTestServer()); | 2248 ASSERT_TRUE(StartEmbeddedTestServer()); |
(...skipping 18 matching lines...) Expand all Loading... |
2208 " \"incognito\": false," | 2267 " \"incognito\": false," |
2209 " \"mime\": \"application/octet-stream\"," | 2268 " \"mime\": \"application/octet-stream\"," |
2210 " \"paused\": false," | 2269 " \"paused\": false," |
2211 " \"id\": %d," | 2270 " \"id\": %d," |
2212 " \"url\": \"%s\"}]", | 2271 " \"url\": \"%s\"}]", |
2213 result_id, | 2272 result_id, |
2214 download_url.c_str()))); | 2273 download_url.c_str()))); |
2215 item->Cancel(true); | 2274 item->Cancel(true); |
2216 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2275 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2217 base::StringPrintf("[{\"id\": %d," | 2276 base::StringPrintf("[{\"id\": %d," |
2218 " \"error\": {\"current\": 40}," | 2277 " \"error\": {\"current\":\"USER_CANCELED\"}," |
2219 " \"state\": {" | 2278 " \"state\": {" |
2220 " \"previous\": \"in_progress\"," | 2279 " \"previous\": \"in_progress\"," |
2221 " \"current\": \"interrupted\"}}]", | 2280 " \"current\": \"interrupted\"}}]", |
2222 result_id))); | 2281 result_id))); |
2223 } | 2282 } |
2224 | 2283 |
2225 // Test downloading filesystem: URLs. | 2284 // Test downloading filesystem: URLs. |
2226 // NOTE: chrome disallows creating HTML5 FileSystem Files in incognito. | 2285 // NOTE: chrome disallows creating HTML5 FileSystem Files in incognito. |
2227 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, | 2286 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest, |
2228 DownloadExtensionTest_Download_FileSystemURL) { | 2287 DownloadExtensionTest_Download_FileSystemURL) { |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2317 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2376 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2318 | 2377 |
2319 // Respond to the onDeterminingFilename. | 2378 // Respond to the onDeterminingFilename. |
2320 std::string error; | 2379 std::string error; |
2321 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 2380 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
2322 browser()->profile(), | 2381 browser()->profile(), |
2323 false, | 2382 false, |
2324 GetExtensionId(), | 2383 GetExtensionId(), |
2325 result_id, | 2384 result_id, |
2326 base::FilePath(), | 2385 base::FilePath(), |
2327 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2386 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2328 &error)); | 2387 &error)); |
2329 EXPECT_EQ("", error); | 2388 EXPECT_EQ("", error); |
2330 | 2389 |
2331 // The download should complete successfully. | 2390 // The download should complete successfully. |
2332 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2391 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2333 base::StringPrintf("[{\"id\": %d," | 2392 base::StringPrintf("[{\"id\": %d," |
2334 " \"filename\": {" | 2393 " \"filename\": {" |
2335 " \"previous\": \"\"," | 2394 " \"previous\": \"\"," |
2336 " \"current\": \"%s\"}}]", | 2395 " \"current\": \"%s\"}}]", |
2337 result_id, | 2396 result_id, |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2384 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2443 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2385 | 2444 |
2386 // Respond to the onDeterminingFilename. | 2445 // Respond to the onDeterminingFilename. |
2387 std::string error; | 2446 std::string error; |
2388 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 2447 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
2389 browser()->profile(), | 2448 browser()->profile(), |
2390 false, | 2449 false, |
2391 GetExtensionId(), | 2450 GetExtensionId(), |
2392 result_id, | 2451 result_id, |
2393 base::FilePath(FILE_PATH_LITERAL("overridden.swf")), | 2452 base::FilePath(FILE_PATH_LITERAL("overridden.swf")), |
2394 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2453 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2395 &error)); | 2454 &error)); |
2396 EXPECT_EQ("", error); | 2455 EXPECT_EQ("", error); |
2397 | 2456 |
2398 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2457 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2399 base::StringPrintf("[{\"id\": %d," | 2458 base::StringPrintf("[{\"id\": %d," |
2400 " \"danger\": {" | 2459 " \"danger\": {" |
2401 " \"previous\":\"safe\"," | 2460 " \"previous\":\"safe\"," |
2402 " \"current\":\"file\"}," | 2461 " \"current\":\"file\"}}]", |
2403 " \"dangerAccepted\": {" | |
2404 " \"current\":false}}]", | |
2405 result_id))); | 2462 result_id))); |
2406 | 2463 |
2407 item->ValidateDangerousDownload(); | 2464 item->ValidateDangerousDownload(); |
2408 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2465 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2409 base::StringPrintf("[{\"id\": %d," | 2466 base::StringPrintf("[{\"id\": %d," |
2410 " \"dangerAccepted\": {" | 2467 " \"danger\": {" |
2411 " \"previous\":false," | 2468 " \"previous\":\"file\"," |
2412 " \"current\":true}}]", | 2469 " \"current\":\"accepted\"}}]", |
2413 result_id))); | 2470 result_id))); |
2414 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2471 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2415 base::StringPrintf("[{\"id\": %d," | 2472 base::StringPrintf("[{\"id\": %d," |
2416 " \"state\": {" | 2473 " \"state\": {" |
2417 " \"previous\": \"in_progress\"," | 2474 " \"previous\": \"in_progress\"," |
2418 " \"current\": \"complete\"}}]", | 2475 " \"current\": \"complete\"}}]", |
2419 result_id))); | 2476 result_id))); |
2420 EXPECT_EQ(downloads_directory().AppendASCII("overridden.swf"), | 2477 EXPECT_EQ(downloads_directory().AppendASCII("overridden.swf"), |
2421 item->GetTargetFilePath()); | 2478 item->GetTargetFilePath()); |
2422 } | 2479 } |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2461 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2518 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2462 | 2519 |
2463 // Respond to the onDeterminingFilename. | 2520 // Respond to the onDeterminingFilename. |
2464 std::string error; | 2521 std::string error; |
2465 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2522 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2466 browser()->profile(), | 2523 browser()->profile(), |
2467 false, | 2524 false, |
2468 GetExtensionId(), | 2525 GetExtensionId(), |
2469 result_id, | 2526 result_id, |
2470 base::FilePath(FILE_PATH_LITERAL("sneaky/../../sneaky.txt")), | 2527 base::FilePath(FILE_PATH_LITERAL("sneaky/../../sneaky.txt")), |
2471 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2528 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2472 &error)); | 2529 &error)); |
2473 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2530 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2474 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2531 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2475 base::StringPrintf("[{\"id\": %d," | 2532 base::StringPrintf("[{\"id\": %d," |
2476 " \"filename\": {" | 2533 " \"filename\": {" |
2477 " \"previous\": \"\"," | 2534 " \"previous\": \"\"," |
2478 " \"current\": \"%s\"}}]", | 2535 " \"current\": \"%s\"}}]", |
2479 result_id, | 2536 result_id, |
2480 GetFilename("slow.txt").c_str()))); | 2537 GetFilename("slow.txt").c_str()))); |
2481 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2538 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2482 base::StringPrintf("[{\"id\": %d," | 2539 base::StringPrintf("[{\"id\": %d," |
2483 " \"state\": {" | 2540 " \"state\": {" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2526 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2583 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2527 | 2584 |
2528 // Respond to the onDeterminingFilename. | 2585 // Respond to the onDeterminingFilename. |
2529 std::string error; | 2586 std::string error; |
2530 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2587 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2531 browser()->profile(), | 2588 browser()->profile(), |
2532 false, | 2589 false, |
2533 GetExtensionId(), | 2590 GetExtensionId(), |
2534 result_id, | 2591 result_id, |
2535 base::FilePath(FILE_PATH_LITERAL("<")), | 2592 base::FilePath(FILE_PATH_LITERAL("<")), |
2536 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2593 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2537 &error)); | 2594 &error)); |
2538 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2595 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2539 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( | 2596 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( |
2540 "[{\"id\": %d," | 2597 "[{\"id\": %d," |
2541 " \"filename\": {" | 2598 " \"filename\": {" |
2542 " \"previous\": \"\"," | 2599 " \"previous\": \"\"," |
2543 " \"current\": \"%s\"}}]", | 2600 " \"current\": \"%s\"}}]", |
2544 result_id, | 2601 result_id, |
2545 GetFilename("slow.txt").c_str()))); | 2602 GetFilename("slow.txt").c_str()))); |
2546 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( | 2603 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( |
2547 "[{\"id\": %d," | 2604 "[{\"id\": %d," |
2548 " \"state\": {" | 2605 " \"state\": {" |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2592 | 2649 |
2593 // Respond to the onDeterminingFilename. | 2650 // Respond to the onDeterminingFilename. |
2594 std::string error; | 2651 std::string error; |
2595 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2652 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2596 browser()->profile(), | 2653 browser()->profile(), |
2597 false, | 2654 false, |
2598 GetExtensionId(), | 2655 GetExtensionId(), |
2599 result_id, | 2656 result_id, |
2600 base::FilePath(FILE_PATH_LITERAL( | 2657 base::FilePath(FILE_PATH_LITERAL( |
2601 "My Computer.{20D04FE0-3AEA-1069-A2D8-08002B30309D}/foo")), | 2658 "My Computer.{20D04FE0-3AEA-1069-A2D8-08002B30309D}/foo")), |
2602 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2659 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2603 &error)); | 2660 &error)); |
2604 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2661 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2605 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( | 2662 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( |
2606 "[{\"id\": %d," | 2663 "[{\"id\": %d," |
2607 " \"filename\": {" | 2664 " \"filename\": {" |
2608 " \"previous\": \"\"," | 2665 " \"previous\": \"\"," |
2609 " \"current\": \"%s\"}}]", | 2666 " \"current\": \"%s\"}}]", |
2610 result_id, | 2667 result_id, |
2611 GetFilename("slow.txt").c_str()))); | 2668 GetFilename("slow.txt").c_str()))); |
2612 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( | 2669 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( |
2613 "[{\"id\": %d," | 2670 "[{\"id\": %d," |
2614 " \"state\": {" | 2671 " \"state\": {" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2657 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2714 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2658 | 2715 |
2659 // Respond to the onDeterminingFilename. | 2716 // Respond to the onDeterminingFilename. |
2660 std::string error; | 2717 std::string error; |
2661 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2718 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2662 browser()->profile(), | 2719 browser()->profile(), |
2663 false, | 2720 false, |
2664 GetExtensionId(), | 2721 GetExtensionId(), |
2665 result_id, | 2722 result_id, |
2666 base::FilePath(FILE_PATH_LITERAL("con.foo")), | 2723 base::FilePath(FILE_PATH_LITERAL("con.foo")), |
2667 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2724 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2668 &error)); | 2725 &error)); |
2669 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2726 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2670 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( | 2727 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( |
2671 "[{\"id\": %d," | 2728 "[{\"id\": %d," |
2672 " \"filename\": {" | 2729 " \"filename\": {" |
2673 " \"previous\": \"\"," | 2730 " \"previous\": \"\"," |
2674 " \"current\": \"%s\"}}]", | 2731 " \"current\": \"%s\"}}]", |
2675 result_id, | 2732 result_id, |
2676 GetFilename("slow.txt").c_str()))); | 2733 GetFilename("slow.txt").c_str()))); |
2677 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( | 2734 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, base::StringPrintf( |
2678 "[{\"id\": %d," | 2735 "[{\"id\": %d," |
2679 " \"state\": {" | 2736 " \"state\": {" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2722 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2779 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2723 | 2780 |
2724 // Respond to the onDeterminingFilename. | 2781 // Respond to the onDeterminingFilename. |
2725 std::string error; | 2782 std::string error; |
2726 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2783 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2727 browser()->profile(), | 2784 browser()->profile(), |
2728 false, | 2785 false, |
2729 GetExtensionId(), | 2786 GetExtensionId(), |
2730 result_id, | 2787 result_id, |
2731 base::FilePath(FILE_PATH_LITERAL(".")), | 2788 base::FilePath(FILE_PATH_LITERAL(".")), |
2732 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2789 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2733 &error)); | 2790 &error)); |
2734 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2791 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2735 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2792 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2736 base::StringPrintf("[{\"id\": %d," | 2793 base::StringPrintf("[{\"id\": %d," |
2737 " \"filename\": {" | 2794 " \"filename\": {" |
2738 " \"previous\": \"\"," | 2795 " \"previous\": \"\"," |
2739 " \"current\": \"%s\"}}]", | 2796 " \"current\": \"%s\"}}]", |
2740 result_id, | 2797 result_id, |
2741 GetFilename("slow.txt").c_str()))); | 2798 GetFilename("slow.txt").c_str()))); |
2742 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2799 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2743 base::StringPrintf("[{\"id\": %d," | 2800 base::StringPrintf("[{\"id\": %d," |
2744 " \"state\": {" | 2801 " \"state\": {" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2787 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2844 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2788 | 2845 |
2789 // Respond to the onDeterminingFilename. | 2846 // Respond to the onDeterminingFilename. |
2790 std::string error; | 2847 std::string error; |
2791 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2848 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2792 browser()->profile(), | 2849 browser()->profile(), |
2793 false, | 2850 false, |
2794 GetExtensionId(), | 2851 GetExtensionId(), |
2795 result_id, | 2852 result_id, |
2796 base::FilePath(FILE_PATH_LITERAL("..")), | 2853 base::FilePath(FILE_PATH_LITERAL("..")), |
2797 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2854 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2798 &error)); | 2855 &error)); |
2799 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2856 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2800 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2857 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2801 base::StringPrintf("[{\"id\": %d," | 2858 base::StringPrintf("[{\"id\": %d," |
2802 " \"filename\": {" | 2859 " \"filename\": {" |
2803 " \"previous\": \"\"," | 2860 " \"previous\": \"\"," |
2804 " \"current\": \"%s\"}}]", | 2861 " \"current\": \"%s\"}}]", |
2805 result_id, | 2862 result_id, |
2806 GetFilename("slow.txt").c_str()))); | 2863 GetFilename("slow.txt").c_str()))); |
2807 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2864 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2808 base::StringPrintf("[{\"id\": %d," | 2865 base::StringPrintf("[{\"id\": %d," |
2809 " \"state\": {" | 2866 " \"state\": {" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2852 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2909 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2853 | 2910 |
2854 // Respond to the onDeterminingFilename. Absolute paths should be rejected. | 2911 // Respond to the onDeterminingFilename. Absolute paths should be rejected. |
2855 std::string error; | 2912 std::string error; |
2856 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2913 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2857 browser()->profile(), | 2914 browser()->profile(), |
2858 false, | 2915 false, |
2859 GetExtensionId(), | 2916 GetExtensionId(), |
2860 result_id, | 2917 result_id, |
2861 downloads_directory().Append(FILE_PATH_LITERAL("sneaky.txt")), | 2918 downloads_directory().Append(FILE_PATH_LITERAL("sneaky.txt")), |
2862 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2919 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2863 &error)); | 2920 &error)); |
2864 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2921 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2865 | 2922 |
2866 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2923 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2867 base::StringPrintf("[{\"id\": %d," | 2924 base::StringPrintf("[{\"id\": %d," |
2868 " \"filename\": {" | 2925 " \"filename\": {" |
2869 " \"previous\": \"\"," | 2926 " \"previous\": \"\"," |
2870 " \"current\": \"%s\"}}]", | 2927 " \"current\": \"%s\"}}]", |
2871 result_id, | 2928 result_id, |
2872 GetFilename("slow.txt").c_str()))); | 2929 GetFilename("slow.txt").c_str()))); |
2873 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2930 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2874 base::StringPrintf("[{\"id\": %d," | 2931 base::StringPrintf("[{\"id\": %d," |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2918 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 2975 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2919 | 2976 |
2920 // Respond to the onDeterminingFilename. Empty basenames should be rejected. | 2977 // Respond to the onDeterminingFilename. Empty basenames should be rejected. |
2921 std::string error; | 2978 std::string error; |
2922 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( | 2979 ASSERT_FALSE(ExtensionDownloadsEventRouter::DetermineFilename( |
2923 browser()->profile(), | 2980 browser()->profile(), |
2924 false, | 2981 false, |
2925 GetExtensionId(), | 2982 GetExtensionId(), |
2926 result_id, | 2983 result_id, |
2927 base::FilePath(FILE_PATH_LITERAL("foo/")), | 2984 base::FilePath(FILE_PATH_LITERAL("foo/")), |
2928 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 2985 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2929 &error)); | 2986 &error)); |
2930 EXPECT_STREQ(download_extension_errors::kInvalidFilenameError, error.c_str()); | 2987 EXPECT_STREQ(errors::kInvalidFilename, error.c_str()); |
2931 | 2988 |
2932 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2989 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2933 base::StringPrintf("[{\"id\": %d," | 2990 base::StringPrintf("[{\"id\": %d," |
2934 " \"filename\": {" | 2991 " \"filename\": {" |
2935 " \"previous\": \"\"," | 2992 " \"previous\": \"\"," |
2936 " \"current\": \"%s\"}}]", | 2993 " \"current\": \"%s\"}}]", |
2937 result_id, | 2994 result_id, |
2938 GetFilename("slow.txt").c_str()))); | 2995 GetFilename("slow.txt").c_str()))); |
2939 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 2996 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2940 base::StringPrintf("[{\"id\": %d," | 2997 base::StringPrintf("[{\"id\": %d," |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2983 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 3040 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
2984 | 3041 |
2985 // Respond to the onDeterminingFilename. | 3042 // Respond to the onDeterminingFilename. |
2986 std::string error; | 3043 std::string error; |
2987 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3044 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
2988 browser()->profile(), | 3045 browser()->profile(), |
2989 false, | 3046 false, |
2990 GetExtensionId(), | 3047 GetExtensionId(), |
2991 result_id, | 3048 result_id, |
2992 base::FilePath(), | 3049 base::FilePath(), |
2993 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 3050 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
2994 &error)); | 3051 &error)); |
2995 EXPECT_EQ("", error); | 3052 EXPECT_EQ("", error); |
2996 | 3053 |
2997 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3054 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
2998 base::StringPrintf("[{\"id\": %d," | 3055 base::StringPrintf("[{\"id\": %d," |
2999 " \"filename\": {" | 3056 " \"filename\": {" |
3000 " \"previous\": \"\"," | 3057 " \"previous\": \"\"," |
3001 " \"current\": \"%s\"}}]", | 3058 " \"current\": \"%s\"}}]", |
3002 result_id, | 3059 result_id, |
3003 GetFilename("slow.txt").c_str()))); | 3060 GetFilename("slow.txt").c_str()))); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3041 // Also test that DetermineFilename allows (chrome) extensions to set | 3098 // Also test that DetermineFilename allows (chrome) extensions to set |
3042 // filenames without (filename) extensions. (Don't ask about v8 extensions or | 3099 // filenames without (filename) extensions. (Don't ask about v8 extensions or |
3043 // python extensions or kernel extensions or firefox extensions...) | 3100 // python extensions or kernel extensions or firefox extensions...) |
3044 error = ""; | 3101 error = ""; |
3045 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3102 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
3046 browser()->profile(), | 3103 browser()->profile(), |
3047 false, | 3104 false, |
3048 GetExtensionId(), | 3105 GetExtensionId(), |
3049 result_id, | 3106 result_id, |
3050 base::FilePath(FILE_PATH_LITERAL("foo")), | 3107 base::FilePath(FILE_PATH_LITERAL("foo")), |
3051 extensions::api::downloads::FILENAME_CONFLICT_ACTION_OVERWRITE, | 3108 api::FILENAME_CONFLICT_ACTION_OVERWRITE, |
3052 &error)); | 3109 &error)); |
3053 EXPECT_EQ("", error); | 3110 EXPECT_EQ("", error); |
3054 | 3111 |
3055 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3112 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3056 base::StringPrintf("[{\"id\": %d," | 3113 base::StringPrintf("[{\"id\": %d," |
3057 " \"filename\": {" | 3114 " \"filename\": {" |
3058 " \"previous\": \"\"," | 3115 " \"previous\": \"\"," |
3059 " \"current\": \"%s\"}}]", | 3116 " \"current\": \"%s\"}}]", |
3060 result_id, | 3117 result_id, |
3061 GetFilename("foo").c_str()))); | 3118 GetFilename("foo").c_str()))); |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3166 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 3223 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
3167 | 3224 |
3168 // Respond to the onDeterminingFilename events. | 3225 // Respond to the onDeterminingFilename events. |
3169 std::string error; | 3226 std::string error; |
3170 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3227 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
3171 current_browser()->profile(), | 3228 current_browser()->profile(), |
3172 false, | 3229 false, |
3173 GetExtensionId(), | 3230 GetExtensionId(), |
3174 result_id, | 3231 result_id, |
3175 base::FilePath(FILE_PATH_LITERAL("42.txt")), | 3232 base::FilePath(FILE_PATH_LITERAL("42.txt")), |
3176 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 3233 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
3177 &error)); | 3234 &error)); |
3178 EXPECT_EQ("", error); | 3235 EXPECT_EQ("", error); |
3179 | 3236 |
3180 // The download should complete successfully. | 3237 // The download should complete successfully. |
3181 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3238 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3182 base::StringPrintf("[{\"id\": %d," | 3239 base::StringPrintf("[{\"id\": %d," |
3183 " \"filename\": {" | 3240 " \"filename\": {" |
3184 " \"previous\": \"\"," | 3241 " \"previous\": \"\"," |
3185 " \"current\": \"%s\"}}]", | 3242 " \"current\": \"%s\"}}]", |
3186 result_id, | 3243 result_id, |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3225 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 3282 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
3226 | 3283 |
3227 // Respond to the onDeterminingFilename. | 3284 // Respond to the onDeterminingFilename. |
3228 error = ""; | 3285 error = ""; |
3229 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3286 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
3230 current_browser()->profile(), | 3287 current_browser()->profile(), |
3231 false, | 3288 false, |
3232 GetExtensionId(), | 3289 GetExtensionId(), |
3233 result_id, | 3290 result_id, |
3234 base::FilePath(FILE_PATH_LITERAL("5.txt")), | 3291 base::FilePath(FILE_PATH_LITERAL("5.txt")), |
3235 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 3292 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
3236 &error)); | 3293 &error)); |
3237 EXPECT_EQ("", error); | 3294 EXPECT_EQ("", error); |
3238 | 3295 |
3239 // The download should complete successfully. | 3296 // The download should complete successfully. |
3240 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3297 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3241 base::StringPrintf("[{\"id\": %d," | 3298 base::StringPrintf("[{\"id\": %d," |
3242 " \"filename\": {" | 3299 " \"filename\": {" |
3243 " \"previous\": \"\"," | 3300 " \"previous\": \"\"," |
3244 " \"current\": \"%s\"}}]", | 3301 " \"current\": \"%s\"}}]", |
3245 result_id, | 3302 result_id, |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3300 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 3357 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
3301 | 3358 |
3302 // Respond to the onDeterminingFilename events. | 3359 // Respond to the onDeterminingFilename events. |
3303 std::string error; | 3360 std::string error; |
3304 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3361 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
3305 current_browser()->profile(), | 3362 current_browser()->profile(), |
3306 true, | 3363 true, |
3307 GetExtensionId(), | 3364 GetExtensionId(), |
3308 result_id, | 3365 result_id, |
3309 base::FilePath(FILE_PATH_LITERAL("42.txt")), | 3366 base::FilePath(FILE_PATH_LITERAL("42.txt")), |
3310 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 3367 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
3311 &error)); | 3368 &error)); |
3312 EXPECT_EQ("", error); | 3369 EXPECT_EQ("", error); |
3313 | 3370 |
3314 // The download should complete successfully. | 3371 // The download should complete successfully. |
3315 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3372 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3316 base::StringPrintf("[{\"id\": %d," | 3373 base::StringPrintf("[{\"id\": %d," |
3317 " \"filename\": {" | 3374 " \"filename\": {" |
3318 " \"previous\": \"\"," | 3375 " \"previous\": \"\"," |
3319 " \"current\": \"%s\"}}]", | 3376 " \"current\": \"%s\"}}]", |
3320 result_id, | 3377 result_id, |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3358 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); | 3415 ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState()); |
3359 | 3416 |
3360 // Respond to the onDeterminingFilename. | 3417 // Respond to the onDeterminingFilename. |
3361 error = ""; | 3418 error = ""; |
3362 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3419 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
3363 current_browser()->profile(), | 3420 current_browser()->profile(), |
3364 true, | 3421 true, |
3365 GetExtensionId(), | 3422 GetExtensionId(), |
3366 result_id, | 3423 result_id, |
3367 base::FilePath(FILE_PATH_LITERAL("42.txt")), | 3424 base::FilePath(FILE_PATH_LITERAL("42.txt")), |
3368 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 3425 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
3369 &error)); | 3426 &error)); |
3370 EXPECT_EQ("", error); | 3427 EXPECT_EQ("", error); |
3371 | 3428 |
3372 // The download should complete successfully. | 3429 // The download should complete successfully. |
3373 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3430 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3374 base::StringPrintf("[{\"id\": %d," | 3431 base::StringPrintf("[{\"id\": %d," |
3375 " \"filename\": {" | 3432 " \"filename\": {" |
3376 " \"previous\": \"\"," | 3433 " \"previous\": \"\"," |
3377 " \"current\": \"%s\"}}]", | 3434 " \"current\": \"%s\"}}]", |
3378 result_id, | 3435 result_id, |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3464 | 3521 |
3465 // Errors caught before filename determination are delayed until after | 3522 // Errors caught before filename determination are delayed until after |
3466 // filename determination. | 3523 // filename determination. |
3467 std::string error; | 3524 std::string error; |
3468 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( | 3525 ASSERT_TRUE(ExtensionDownloadsEventRouter::DetermineFilename( |
3469 current_browser()->profile(), | 3526 current_browser()->profile(), |
3470 false, | 3527 false, |
3471 GetExtensionId(), | 3528 GetExtensionId(), |
3472 item->GetId(), | 3529 item->GetId(), |
3473 base::FilePath(FILE_PATH_LITERAL("42.txt")), | 3530 base::FilePath(FILE_PATH_LITERAL("42.txt")), |
3474 extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY, | 3531 api::FILENAME_CONFLICT_ACTION_UNIQUIFY, |
3475 &error)) << error; | 3532 &error)) << error; |
3476 EXPECT_EQ("", error); | 3533 EXPECT_EQ("", error); |
3477 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3534 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3478 base::StringPrintf("[{\"id\": %d," | 3535 base::StringPrintf("[{\"id\": %d," |
3479 " \"filename\": {" | 3536 " \"filename\": {" |
3480 " \"previous\": \"\"," | 3537 " \"previous\": \"\"," |
3481 " \"current\": \"%s\"}}]", | 3538 " \"current\": \"%s\"}}]", |
3482 item->GetId(), | 3539 item->GetId(), |
3483 GetFilename("42.txt").c_str()))); | 3540 GetFilename("42.txt").c_str()))); |
3484 | 3541 |
3485 content::DownloadUpdatedObserver interrupted(item, base::Bind( | 3542 content::DownloadUpdatedObserver interrupted(item, base::Bind( |
3486 ItemIsInterrupted)); | 3543 ItemIsInterrupted)); |
3487 ASSERT_TRUE(interrupted.WaitForEvent()); | 3544 ASSERT_TRUE(interrupted.WaitForEvent()); |
3488 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3545 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3489 base::StringPrintf("[{\"id\": %d," | 3546 base::StringPrintf("[{\"id\": %d," |
3490 " \"error\":{\"current\":20}," | 3547 " \"error\":{\"current\":\"NETWORK_FAILED\"}," |
3491 " \"state\":{" | 3548 " \"state\":{" |
3492 " \"previous\":\"in_progress\"," | 3549 " \"previous\":\"in_progress\"," |
3493 " \"current\":\"interrupted\"}}]", | 3550 " \"current\":\"interrupted\"}}]", |
3494 item->GetId()))); | 3551 item->GetId()))); |
3495 | 3552 |
3496 ClearEvents(); | 3553 ClearEvents(); |
3497 // Downloads that are restarted on resumption trigger another download target | 3554 // Downloads that are restarted on resumption trigger another download target |
3498 // determination. | 3555 // determination. |
3499 RemoveFilenameDeterminer(host); | 3556 RemoveFilenameDeterminer(host); |
3500 item->Resume(); | 3557 item->Resume(); |
3501 | 3558 |
3502 // Errors caught before filename determination is complete are delayed until | 3559 // Errors caught before filename determination is complete are delayed until |
3503 // after filename determination so that, on resumption, filename determination | 3560 // after filename determination so that, on resumption, filename determination |
3504 // does not need to be re-done. So, there will not be a second | 3561 // does not need to be re-done. So, there will not be a second |
3505 // onDeterminingFilename event. | 3562 // onDeterminingFilename event. |
3506 | 3563 |
3507 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3564 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
3508 base::StringPrintf("[{\"id\": %d," | 3565 base::StringPrintf("[{\"id\": %d," |
3509 " \"error\":{\"previous\":20}," | 3566 " \"error\":{\"previous\":\"NETWORK_FAILED\"}," |
3510 " \"state\":{" | 3567 " \"state\":{" |
3511 " \"previous\":\"interrupted\"," | 3568 " \"previous\":\"interrupted\"," |
3512 " \"current\":\"in_progress\"}}]", | 3569 " \"current\":\"in_progress\"}}]", |
3513 item->GetId()))); | 3570 item->GetId()))); |
3514 | 3571 |
3515 ClearEvents(); | 3572 ClearEvents(); |
3516 FinishPendingSlowDownloads(); | 3573 FinishPendingSlowDownloads(); |
3517 | 3574 |
3518 // The download should complete successfully. | 3575 // The download should complete successfully. |
3519 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, | 3576 ASSERT_TRUE(WaitFor(events::kOnDownloadChanged, |
(...skipping 15 matching lines...) Expand all Loading... |
3535 DownloadsApiTest() {} | 3592 DownloadsApiTest() {} |
3536 virtual ~DownloadsApiTest() {} | 3593 virtual ~DownloadsApiTest() {} |
3537 private: | 3594 private: |
3538 DISALLOW_COPY_AND_ASSIGN(DownloadsApiTest); | 3595 DISALLOW_COPY_AND_ASSIGN(DownloadsApiTest); |
3539 }; | 3596 }; |
3540 | 3597 |
3541 | 3598 |
3542 IN_PROC_BROWSER_TEST_F(DownloadsApiTest, DownloadsApiTest) { | 3599 IN_PROC_BROWSER_TEST_F(DownloadsApiTest, DownloadsApiTest) { |
3543 ASSERT_TRUE(RunExtensionTest("downloads")) << message_; | 3600 ASSERT_TRUE(RunExtensionTest("downloads")) << message_; |
3544 } | 3601 } |
| 3602 |
| 3603 |
| 3604 TEST(DownloadInterruptReasonEnumsSynced, |
| 3605 DownloadInterruptReasonEnumsSynced) { |
| 3606 #define INTERRUPT_REASON(name, value) \ |
| 3607 EXPECT_EQ(InterruptReasonContentToExtension( \ |
| 3608 content::DOWNLOAD_INTERRUPT_REASON_##name), \ |
| 3609 api::INTERRUPT_REASON_##name); \ |
| 3610 EXPECT_EQ(InterruptReasonExtensionToContent( \ |
| 3611 api::INTERRUPT_REASON_##name), \ |
| 3612 content::DOWNLOAD_INTERRUPT_REASON_##name); |
| 3613 #include "content/public/browser/download_interrupt_reason_values.h" |
| 3614 #undef INTERRUPT_REASON |
| 3615 } |
OLD | NEW |