network_fetcher_task.cc 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "android_webview/nonembedded/net/network_fetcher_task.h"
  5. #include <string>
  6. #include <utility>
  7. #include <vector>
  8. #include "android_webview/nonembedded/net/network_impl.h"
  9. #include "android_webview/nonembedded/nonembedded_jni_headers/NetworkFetcherTask_jni.h"
  10. #include "base/android/jni_array.h"
  11. #include "base/android/jni_string.h"
  12. #include "base/callback.h"
  13. #include "base/check.h"
  14. #include "base/files/file_path.h"
  15. #include "base/location.h"
  16. #include "base/memory/scoped_refptr.h"
  17. #include "base/memory/weak_ptr.h"
  18. #include "base/sequence_checker.h"
  19. #include "base/task/sequenced_task_runner.h"
  20. #include "base/task/task_traits.h"
  21. #include "base/task/thread_pool.h"
  22. #include "url/android/gurl_android.h"
  23. #include "url/gurl.h"
  24. namespace android_webview {
  25. namespace {
  26. using TaskWeakPtr = base::WeakPtr<NetworkFetcherTask>;
  27. void InvokePostRequest(
  28. TaskWeakPtr weak_ptr,
  29. scoped_refptr<base::SequencedTaskRunner> task_runner,
  30. const GURL& url,
  31. const std::string& post_data,
  32. const std::string& content_type,
  33. const base::flat_map<std::string, std::string>& post_additional_headers) {
  34. JNIEnv* env = base::android::AttachCurrentThread();
  35. std::vector<std::string> keys, values;
  36. for (auto const& header : post_additional_headers) {
  37. keys.push_back(header.first);
  38. values.push_back(header.second);
  39. }
  40. Java_NetworkFetcherTask_postRequest(
  41. env, reinterpret_cast<intptr_t>(&weak_ptr),
  42. reinterpret_cast<intptr_t>(task_runner.get()),
  43. url::GURLAndroid::FromNativeGURL(env, url),
  44. base::android::ToJavaByteArray(env, post_data),
  45. base::android::ConvertUTF8ToJavaString(env, content_type),
  46. base::android::ToJavaArrayOfStrings(env, keys),
  47. base::android::ToJavaArrayOfStrings(env, values));
  48. }
  49. void InvokeDownload(TaskWeakPtr weak_ptr,
  50. scoped_refptr<base::SequencedTaskRunner> task_runner,
  51. const GURL& url,
  52. const base::FilePath& file_path) {
  53. JNIEnv* env = base::android::AttachCurrentThread();
  54. Java_NetworkFetcherTask_download(
  55. env, reinterpret_cast<intptr_t>(&weak_ptr),
  56. reinterpret_cast<intptr_t>(task_runner.get()),
  57. url::GURLAndroid::FromNativeGURL(env, url),
  58. base::android::ConvertUTF8ToJavaString(env, file_path.value()));
  59. }
  60. } // namespace
  61. // static
  62. void JNI_NetworkFetcherTask_CallProgressCallback(JNIEnv* env,
  63. jlong weak_ptr,
  64. jlong task_runner,
  65. jlong current) {
  66. auto* native_task_runner =
  67. reinterpret_cast<base::SequencedTaskRunner*>(task_runner);
  68. DCHECK(native_task_runner);
  69. auto* task = reinterpret_cast<TaskWeakPtr*>(weak_ptr);
  70. native_task_runner->PostTask(
  71. FROM_HERE, base::BindOnce(&NetworkFetcherTask::InvokeProgressCallback,
  72. *task, current));
  73. }
  74. // static
  75. void JNI_NetworkFetcherTask_CallResponseStartedCallback(JNIEnv* env,
  76. jlong weak_ptr,
  77. jlong task_runner,
  78. jint response_code,
  79. jlong content_length) {
  80. auto* native_task_runner =
  81. reinterpret_cast<base::SequencedTaskRunner*>(task_runner);
  82. DCHECK(native_task_runner);
  83. auto* task = reinterpret_cast<TaskWeakPtr*>(weak_ptr);
  84. native_task_runner->PostTask(
  85. FROM_HERE,
  86. base::BindOnce(&NetworkFetcherTask::InvokeResponseStartedCallback, *task,
  87. response_code, content_length));
  88. }
  89. // static
  90. void JNI_NetworkFetcherTask_CallDownloadToFileCompleteCallback(
  91. JNIEnv* env,
  92. jlong weak_ptr,
  93. jlong task_runner,
  94. jint network_error,
  95. jlong content_size) {
  96. auto* native_task_runner =
  97. reinterpret_cast<base::SequencedTaskRunner*>(task_runner);
  98. DCHECK(native_task_runner);
  99. auto* task = reinterpret_cast<TaskWeakPtr*>(weak_ptr);
  100. native_task_runner->PostTask(
  101. FROM_HERE,
  102. base::BindOnce(&NetworkFetcherTask::InvokeDownloadToFileCompleteCallback,
  103. *task, network_error, content_size));
  104. }
  105. // static
  106. void JNI_NetworkFetcherTask_CallPostRequestCompleteCallback(
  107. JNIEnv* env,
  108. jlong weak_ptr,
  109. jlong task_runner,
  110. const base::android::JavaParamRef<jbyteArray>& response_body,
  111. jint network_error,
  112. const base::android::JavaParamRef<jstring>& header_e_tag,
  113. const base::android::JavaParamRef<jstring>& header_x_cup_server_proof,
  114. jlong x_header_retry_after_sec) {
  115. auto* native_task_runner =
  116. reinterpret_cast<base::SequencedTaskRunner*>(task_runner);
  117. DCHECK(native_task_runner);
  118. auto* task = reinterpret_cast<TaskWeakPtr*>(weak_ptr);
  119. std::string response_body_str;
  120. base::android::JavaByteArrayToString(env, response_body, &response_body_str);
  121. native_task_runner->PostTask(
  122. FROM_HERE,
  123. base::BindOnce(&NetworkFetcherTask::InvokePostRequestCompleteCallback,
  124. *task, std::make_unique<std::string>(response_body_str),
  125. network_error,
  126. base::android::ConvertJavaStringToUTF8(env, header_e_tag),
  127. base::android::ConvertJavaStringToUTF8(
  128. env, header_x_cup_server_proof),
  129. x_header_retry_after_sec));
  130. }
  131. // static
  132. std::unique_ptr<NetworkFetcherTask>
  133. NetworkFetcherTask::CreateDownloadToFileTask(
  134. const GURL& url,
  135. const base::FilePath& file_path,
  136. update_client::NetworkFetcher::ResponseStartedCallback
  137. response_started_callback,
  138. update_client::NetworkFetcher::ProgressCallback progress_callback,
  139. update_client::NetworkFetcher::DownloadToFileCompleteCallback
  140. download_to_file_complete_callback) {
  141. return std::make_unique<NetworkFetcherTask>(
  142. url, file_path, std::move(response_started_callback), progress_callback,
  143. std::move(download_to_file_complete_callback));
  144. }
  145. // static
  146. std::unique_ptr<NetworkFetcherTask> NetworkFetcherTask::CreatePostRequestTask(
  147. const GURL& url,
  148. const std::string& post_data,
  149. const std::string& content_type,
  150. const base::flat_map<std::string, std::string>& post_additional_headers,
  151. update_client::NetworkFetcher::ResponseStartedCallback
  152. response_started_callback,
  153. update_client::NetworkFetcher::ProgressCallback progress_callback,
  154. update_client::NetworkFetcher::PostRequestCompleteCallback
  155. post_request_complete_callback) {
  156. return std::make_unique<NetworkFetcherTask>(
  157. url, post_data, content_type, post_additional_headers,
  158. std::move(response_started_callback), progress_callback,
  159. std::move(post_request_complete_callback));
  160. }
  161. NetworkFetcherTask::NetworkFetcherTask(
  162. const GURL& url,
  163. const base::FilePath& file_path,
  164. update_client::NetworkFetcher::ResponseStartedCallback
  165. response_started_callback,
  166. update_client::NetworkFetcher::ProgressCallback progress_callback,
  167. update_client::NetworkFetcher::DownloadToFileCompleteCallback
  168. download_to_file_complete_callback)
  169. : response_started_callback_(std::move(response_started_callback)),
  170. progress_callback_(std::move(progress_callback)),
  171. download_to_file_complete_callback_(
  172. std::move(download_to_file_complete_callback)) {
  173. base::ThreadPool::PostTask(
  174. FROM_HERE, {base::MayBlock()},
  175. base::BindOnce(&InvokeDownload, weak_ptr_factory_.GetWeakPtr(),
  176. task_runner_, url, file_path));
  177. }
  178. NetworkFetcherTask::NetworkFetcherTask(
  179. const GURL& url,
  180. const std::string& post_data,
  181. const std::string& content_type,
  182. const base::flat_map<std::string, std::string>& post_additional_headers,
  183. update_client::NetworkFetcher::ResponseStartedCallback
  184. response_started_callback,
  185. update_client::NetworkFetcher::ProgressCallback progress_callback,
  186. update_client::NetworkFetcher::PostRequestCompleteCallback
  187. post_request_complete_callback)
  188. : response_started_callback_(std::move(response_started_callback)),
  189. progress_callback_(std::move(progress_callback)),
  190. post_request_complete_callback_(
  191. std::move(post_request_complete_callback)) {
  192. base::ThreadPool::PostTask(
  193. FROM_HERE, {base::MayBlock()},
  194. base::BindOnce(&InvokePostRequest, weak_ptr_factory_.GetWeakPtr(),
  195. task_runner_, url, post_data, content_type,
  196. post_additional_headers));
  197. }
  198. NetworkFetcherTask::~NetworkFetcherTask() = default;
  199. void NetworkFetcherTask::InvokeProgressCallback(int64_t current) {
  200. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  201. progress_callback_.Run(current);
  202. }
  203. void NetworkFetcherTask::InvokeResponseStartedCallback(int response_code,
  204. int64_t content_length) {
  205. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  206. std::move(response_started_callback_).Run(response_code, content_length);
  207. }
  208. void NetworkFetcherTask::InvokeDownloadToFileCompleteCallback(
  209. int network_error,
  210. int64_t content_size) {
  211. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  212. std::move(download_to_file_complete_callback_)
  213. .Run(network_error, content_size);
  214. }
  215. void NetworkFetcherTask::InvokePostRequestCompleteCallback(
  216. std::unique_ptr<std::string> response_body,
  217. int network_error,
  218. const std::string& header_etag,
  219. const std::string& header_x_cup_server_proof,
  220. int64_t x_header_retry_after_sec) {
  221. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  222. std::move(post_request_complete_callback_)
  223. .Run(std::move(response_body), network_error, header_etag,
  224. header_x_cup_server_proof, x_header_retry_after_sec);
  225. }
  226. } // namespace android_webview