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 "android_webview/browser/net/android_stream_reader_url_request_job.h" | 5 #include "android_webview/browser/net/android_stream_reader_url_request_job.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "android_webview/browser/input_stream.h" | 10 #include "android_webview/browser/input_stream.h" |
11 #include "android_webview/browser/net/input_stream_reader.h" | 11 #include "android_webview/browser/net/input_stream_reader.h" |
12 #include "base/android/jni_android.h" | 12 #include "base/android/jni_android.h" |
13 #include "base/android/jni_string.h" | 13 #include "base/android/jni_string.h" |
14 #include "base/bind.h" | 14 #include "base/bind.h" |
15 #include "base/bind_helpers.h" | 15 #include "base/bind_helpers.h" |
16 #include "base/lazy_instance.h" | 16 #include "base/lazy_instance.h" |
| 17 #include "base/memory/ptr_util.h" |
17 #include "base/single_thread_task_runner.h" | 18 #include "base/single_thread_task_runner.h" |
18 #include "base/strings/string_number_conversions.h" | 19 #include "base/strings/string_number_conversions.h" |
19 #include "base/task_runner.h" | 20 #include "base/task_runner.h" |
20 #include "base/thread_task_runner_handle.h" | 21 #include "base/thread_task_runner_handle.h" |
21 #include "base/threading/sequenced_worker_pool.h" | 22 #include "base/threading/sequenced_worker_pool.h" |
22 #include "base/threading/thread.h" | 23 #include "base/threading/thread.h" |
23 #include "content/public/browser/browser_thread.h" | 24 #include "content/public/browser/browser_thread.h" |
24 #include "net/base/io_buffer.h" | 25 #include "net/base/io_buffer.h" |
25 #include "net/base/mime_util.h" | 26 #include "net/base/mime_util.h" |
26 #include "net/http/http_response_headers.h" | 27 #include "net/http/http_response_headers.h" |
(...skipping 20 matching lines...) Expand all Loading... |
47 | 48 |
48 } // namespace | 49 } // namespace |
49 | 50 |
50 // The requests posted to the worker thread might outlive the job. Thread-safe | 51 // The requests posted to the worker thread might outlive the job. Thread-safe |
51 // ref counting is used to ensure that the InputStream and InputStreamReader | 52 // ref counting is used to ensure that the InputStream and InputStreamReader |
52 // members of this class are still there when the closure is run on the worker | 53 // members of this class are still there when the closure is run on the worker |
53 // thread. | 54 // thread. |
54 class InputStreamReaderWrapper : | 55 class InputStreamReaderWrapper : |
55 public base::RefCountedThreadSafe<InputStreamReaderWrapper> { | 56 public base::RefCountedThreadSafe<InputStreamReaderWrapper> { |
56 public: | 57 public: |
57 InputStreamReaderWrapper(scoped_ptr<InputStream> input_stream, | 58 InputStreamReaderWrapper( |
58 scoped_ptr<InputStreamReader> input_stream_reader) | 59 std::unique_ptr<InputStream> input_stream, |
| 60 std::unique_ptr<InputStreamReader> input_stream_reader) |
59 : input_stream_(std::move(input_stream)), | 61 : input_stream_(std::move(input_stream)), |
60 input_stream_reader_(std::move(input_stream_reader)) { | 62 input_stream_reader_(std::move(input_stream_reader)) { |
61 DCHECK(input_stream_); | 63 DCHECK(input_stream_); |
62 DCHECK(input_stream_reader_); | 64 DCHECK(input_stream_reader_); |
63 } | 65 } |
64 | 66 |
65 InputStream* input_stream() { | 67 InputStream* input_stream() { |
66 return input_stream_.get(); | 68 return input_stream_.get(); |
67 } | 69 } |
68 | 70 |
69 int Seek(const net::HttpByteRange& byte_range) { | 71 int Seek(const net::HttpByteRange& byte_range) { |
70 return input_stream_reader_->Seek(byte_range); | 72 return input_stream_reader_->Seek(byte_range); |
71 } | 73 } |
72 | 74 |
73 int ReadRawData(net::IOBuffer* buffer, int buffer_size) { | 75 int ReadRawData(net::IOBuffer* buffer, int buffer_size) { |
74 return input_stream_reader_->ReadRawData(buffer, buffer_size); | 76 return input_stream_reader_->ReadRawData(buffer, buffer_size); |
75 } | 77 } |
76 | 78 |
77 private: | 79 private: |
78 friend class base::RefCountedThreadSafe<InputStreamReaderWrapper>; | 80 friend class base::RefCountedThreadSafe<InputStreamReaderWrapper>; |
79 ~InputStreamReaderWrapper() {} | 81 ~InputStreamReaderWrapper() {} |
80 | 82 |
81 scoped_ptr<InputStream> input_stream_; | 83 std::unique_ptr<InputStream> input_stream_; |
82 scoped_ptr<InputStreamReader> input_stream_reader_; | 84 std::unique_ptr<InputStreamReader> input_stream_reader_; |
83 | 85 |
84 DISALLOW_COPY_AND_ASSIGN(InputStreamReaderWrapper); | 86 DISALLOW_COPY_AND_ASSIGN(InputStreamReaderWrapper); |
85 }; | 87 }; |
86 | 88 |
87 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob( | 89 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob( |
88 net::URLRequest* request, | 90 net::URLRequest* request, |
89 net::NetworkDelegate* network_delegate, | 91 net::NetworkDelegate* network_delegate, |
90 scoped_ptr<Delegate> delegate) | 92 std::unique_ptr<Delegate> delegate) |
91 : URLRequestJob(request, network_delegate), | 93 : URLRequestJob(request, network_delegate), |
92 range_parse_result_(net::OK), | 94 range_parse_result_(net::OK), |
93 delegate_(std::move(delegate)), | 95 delegate_(std::move(delegate)), |
94 weak_factory_(this) { | 96 weak_factory_(this) { |
95 DCHECK(delegate_); | 97 DCHECK(delegate_); |
96 } | 98 } |
97 | 99 |
98 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob( | 100 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob( |
99 net::URLRequest* request, | 101 net::URLRequest* request, |
100 net::NetworkDelegate* network_delegate, | 102 net::NetworkDelegate* network_delegate, |
101 scoped_ptr<DelegateObtainer> delegate_obtainer, | 103 std::unique_ptr<DelegateObtainer> delegate_obtainer, |
102 bool) | 104 bool) |
103 : URLRequestJob(request, network_delegate), | 105 : URLRequestJob(request, network_delegate), |
104 range_parse_result_(net::OK), | 106 range_parse_result_(net::OK), |
105 delegate_obtainer_(std::move(delegate_obtainer)), | 107 delegate_obtainer_(std::move(delegate_obtainer)), |
106 weak_factory_(this) { | 108 weak_factory_(this) { |
107 DCHECK(delegate_obtainer_); | 109 DCHECK(delegate_obtainer_); |
108 } | 110 } |
109 | 111 |
110 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() { | 112 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() { |
111 } | 113 } |
112 | 114 |
113 namespace { | 115 namespace { |
114 | 116 |
115 typedef base::Callback< | 117 typedef base::Callback<void( |
116 void(scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>, | 118 std::unique_ptr<AndroidStreamReaderURLRequestJob::Delegate>, |
117 scoped_ptr<InputStream>)> OnInputStreamOpenedCallback; | 119 std::unique_ptr<InputStream>)> |
| 120 OnInputStreamOpenedCallback; |
118 | 121 |
119 // static | 122 // static |
120 void OpenInputStreamOnWorkerThread( | 123 void OpenInputStreamOnWorkerThread( |
121 scoped_refptr<base::SingleThreadTaskRunner> job_thread_task_runner, | 124 scoped_refptr<base::SingleThreadTaskRunner> job_thread_task_runner, |
122 scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate> delegate, | 125 std::unique_ptr<AndroidStreamReaderURLRequestJob::Delegate> delegate, |
123 const GURL& url, | 126 const GURL& url, |
124 OnInputStreamOpenedCallback callback) { | 127 OnInputStreamOpenedCallback callback) { |
125 JNIEnv* env = AttachCurrentThread(); | 128 JNIEnv* env = AttachCurrentThread(); |
126 DCHECK(env); | 129 DCHECK(env); |
127 | 130 |
128 scoped_ptr<InputStream> input_stream = delegate->OpenInputStream(env, url); | 131 std::unique_ptr<InputStream> input_stream = |
| 132 delegate->OpenInputStream(env, url); |
129 job_thread_task_runner->PostTask( | 133 job_thread_task_runner->PostTask( |
130 FROM_HERE, base::Bind(callback, base::Passed(std::move(delegate)), | 134 FROM_HERE, base::Bind(callback, base::Passed(std::move(delegate)), |
131 base::Passed(std::move(input_stream)))); | 135 base::Passed(std::move(input_stream)))); |
132 } | 136 } |
133 | 137 |
134 } // namespace | 138 } // namespace |
135 | 139 |
136 void AndroidStreamReaderURLRequestJob::Start() { | 140 void AndroidStreamReaderURLRequestJob::Start() { |
137 DCHECK(thread_checker_.CalledOnValidThread()); | 141 DCHECK(thread_checker_.CalledOnValidThread()); |
138 if (!delegate_) { | 142 if (!delegate_) { |
139 DCHECK(delegate_obtainer_); | 143 DCHECK(delegate_obtainer_); |
140 delegate_obtainer_->ObtainDelegate( | 144 delegate_obtainer_->ObtainDelegate( |
141 request(), | 145 request(), |
142 base::Bind(&AndroidStreamReaderURLRequestJob::DelegateObtained, | 146 base::Bind(&AndroidStreamReaderURLRequestJob::DelegateObtained, |
143 weak_factory_.GetWeakPtr())); | 147 weak_factory_.GetWeakPtr())); |
144 } else { | 148 } else { |
145 // Run DoStart asynchronously to avoid re-entering the delegate. | 149 // Run DoStart asynchronously to avoid re-entering the delegate. |
146 base::ThreadTaskRunnerHandle::Get()->PostTask( | 150 base::ThreadTaskRunnerHandle::Get()->PostTask( |
147 FROM_HERE, base::Bind(&AndroidStreamReaderURLRequestJob::DoStart, | 151 FROM_HERE, base::Bind(&AndroidStreamReaderURLRequestJob::DoStart, |
148 weak_factory_.GetWeakPtr())); | 152 weak_factory_.GetWeakPtr())); |
149 } | 153 } |
150 } | 154 } |
151 | 155 |
152 void AndroidStreamReaderURLRequestJob::Kill() { | 156 void AndroidStreamReaderURLRequestJob::Kill() { |
153 DCHECK(thread_checker_.CalledOnValidThread()); | 157 DCHECK(thread_checker_.CalledOnValidThread()); |
154 weak_factory_.InvalidateWeakPtrs(); | 158 weak_factory_.InvalidateWeakPtrs(); |
155 URLRequestJob::Kill(); | 159 URLRequestJob::Kill(); |
156 } | 160 } |
157 | 161 |
158 scoped_ptr<InputStreamReader> | 162 std::unique_ptr<InputStreamReader> |
159 AndroidStreamReaderURLRequestJob::CreateStreamReader(InputStream* stream) { | 163 AndroidStreamReaderURLRequestJob::CreateStreamReader(InputStream* stream) { |
160 return make_scoped_ptr(new InputStreamReader(stream)); | 164 return base::WrapUnique(new InputStreamReader(stream)); |
161 } | 165 } |
162 | 166 |
163 void AndroidStreamReaderURLRequestJob::OnInputStreamOpened( | 167 void AndroidStreamReaderURLRequestJob::OnInputStreamOpened( |
164 scoped_ptr<Delegate> returned_delegate, | 168 std::unique_ptr<Delegate> returned_delegate, |
165 scoped_ptr<android_webview::InputStream> input_stream) { | 169 std::unique_ptr<android_webview::InputStream> input_stream) { |
166 DCHECK(thread_checker_.CalledOnValidThread()); | 170 DCHECK(thread_checker_.CalledOnValidThread()); |
167 DCHECK(returned_delegate); | 171 DCHECK(returned_delegate); |
168 delegate_ = std::move(returned_delegate); | 172 delegate_ = std::move(returned_delegate); |
169 | 173 |
170 if (!input_stream) { | 174 if (!input_stream) { |
171 bool restart_required = false; | 175 bool restart_required = false; |
172 delegate_->OnInputStreamOpenFailed(request(), &restart_required); | 176 delegate_->OnInputStreamOpenFailed(request(), &restart_required); |
173 if (restart_required) { | 177 if (restart_required) { |
174 NotifyRestartRequired(); | 178 NotifyRestartRequired(); |
175 } else { | 179 } else { |
176 HeadersComplete(kHTTPNotFound, kHTTPNotFoundText); | 180 HeadersComplete(kHTTPNotFound, kHTTPNotFoundText); |
177 } | 181 } |
178 return; | 182 return; |
179 } | 183 } |
180 | 184 |
181 scoped_ptr<InputStreamReader> input_stream_reader( | 185 std::unique_ptr<InputStreamReader> input_stream_reader( |
182 CreateStreamReader(input_stream.get())); | 186 CreateStreamReader(input_stream.get())); |
183 DCHECK(input_stream_reader); | 187 DCHECK(input_stream_reader); |
184 | 188 |
185 DCHECK(!input_stream_reader_wrapper_.get()); | 189 DCHECK(!input_stream_reader_wrapper_.get()); |
186 input_stream_reader_wrapper_ = new InputStreamReaderWrapper( | 190 input_stream_reader_wrapper_ = new InputStreamReaderWrapper( |
187 std::move(input_stream), std::move(input_stream_reader)); | 191 std::move(input_stream), std::move(input_stream_reader)); |
188 | 192 |
189 PostTaskAndReplyWithResult( | 193 PostTaskAndReplyWithResult( |
190 GetWorkerThreadRunner(), | 194 GetWorkerThreadRunner(), |
191 FROM_HERE, | 195 FROM_HERE, |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
261 | 265 |
262 // Since it's possible for this call to alter the InputStream a | 266 // Since it's possible for this call to alter the InputStream a |
263 // Seek or ReadRawData operation running in the background is not permitted. | 267 // Seek or ReadRawData operation running in the background is not permitted. |
264 DCHECK(!request_->status().is_io_pending()); | 268 DCHECK(!request_->status().is_io_pending()); |
265 | 269 |
266 return delegate_->GetCharset( | 270 return delegate_->GetCharset( |
267 env, request(), input_stream_reader_wrapper_->input_stream(), charset); | 271 env, request(), input_stream_reader_wrapper_->input_stream(), charset); |
268 } | 272 } |
269 | 273 |
270 void AndroidStreamReaderURLRequestJob::DelegateObtained( | 274 void AndroidStreamReaderURLRequestJob::DelegateObtained( |
271 scoped_ptr<Delegate> delegate) { | 275 std::unique_ptr<Delegate> delegate) { |
272 DCHECK(!delegate_); | 276 DCHECK(!delegate_); |
273 delegate_obtainer_.reset(); | 277 delegate_obtainer_.reset(); |
274 if (delegate) { | 278 if (delegate) { |
275 delegate_.swap(delegate); | 279 delegate_.swap(delegate); |
276 DoStart(); | 280 DoStart(); |
277 } else { | 281 } else { |
278 NotifyRestartRequired(); | 282 NotifyRestartRequired(); |
279 } | 283 } |
280 } | 284 } |
281 | 285 |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
372 byte_range_ = ranges[0]; | 376 byte_range_ = ranges[0]; |
373 } else { | 377 } else { |
374 // We don't support multiple range requests in one single URL request, | 378 // We don't support multiple range requests in one single URL request, |
375 // because we need to do multipart encoding here. | 379 // because we need to do multipart encoding here. |
376 range_parse_result_ = net::ERR_REQUEST_RANGE_NOT_SATISFIABLE; | 380 range_parse_result_ = net::ERR_REQUEST_RANGE_NOT_SATISFIABLE; |
377 } | 381 } |
378 } | 382 } |
379 } | 383 } |
380 | 384 |
381 } // namespace android_webview | 385 } // namespace android_webview |
OLD | NEW |