| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 | |
| 5 #include "net/url_request/sdch_dictionary_fetcher.h" | |
| 6 | |
| 7 #include <stdint.h> | |
| 8 | |
| 9 #include "base/auto_reset.h" | |
| 10 #include "base/bind.h" | |
| 11 #include "base/compiler_specific.h" | |
| 12 #include "base/profiler/scoped_tracker.h" | |
| 13 #include "base/thread_task_runner_handle.h" | |
| 14 #include "net/base/io_buffer.h" | |
| 15 #include "net/base/load_flags.h" | |
| 16 #include "net/base/net_log.h" | |
| 17 #include "net/base/sdch_net_log_params.h" | |
| 18 #include "net/url_request/url_request_context.h" | |
| 19 #include "net/url_request/url_request_status.h" | |
| 20 #include "net/url_request/url_request_throttler_manager.h" | |
| 21 | |
| 22 namespace net { | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 const int kBufferSize = 4096; | |
| 27 | |
| 28 // Map the bytes_read result from a read attempt and a URLRequest's | |
| 29 // status into a single net return value. | |
| 30 int GetReadResult(int bytes_read, const URLRequest* request) { | |
| 31 int rv = request->status().error(); | |
| 32 if (request->status().is_success() && bytes_read < 0) { | |
| 33 rv = ERR_FAILED; | |
| 34 request->net_log().AddEventWithNetErrorCode( | |
| 35 NetLog::TYPE_SDCH_DICTIONARY_FETCH_IMPLIED_ERROR, rv); | |
| 36 } | |
| 37 | |
| 38 if (rv == OK) | |
| 39 rv = bytes_read; | |
| 40 | |
| 41 return rv; | |
| 42 } | |
| 43 | |
| 44 } // namespace | |
| 45 | |
| 46 SdchDictionaryFetcher::SdchDictionaryFetcher( | |
| 47 URLRequestContext* context, | |
| 48 const OnDictionaryFetchedCallback& callback) | |
| 49 : next_state_(STATE_NONE), | |
| 50 in_loop_(false), | |
| 51 context_(context), | |
| 52 dictionary_fetched_callback_(callback), | |
| 53 weak_factory_(this) { | |
| 54 DCHECK(CalledOnValidThread()); | |
| 55 DCHECK(context); | |
| 56 } | |
| 57 | |
| 58 SdchDictionaryFetcher::~SdchDictionaryFetcher() { | |
| 59 DCHECK(CalledOnValidThread()); | |
| 60 } | |
| 61 | |
| 62 void SdchDictionaryFetcher::Schedule(const GURL& dictionary_url) { | |
| 63 DCHECK(CalledOnValidThread()); | |
| 64 | |
| 65 // Avoid pushing duplicate copy onto queue. We may fetch this url again later | |
| 66 // and get a different dictionary, but there is no reason to have it in the | |
| 67 // queue twice at one time. | |
| 68 if ((!fetch_queue_.empty() && fetch_queue_.back() == dictionary_url) || | |
| 69 attempted_load_.find(dictionary_url) != attempted_load_.end()) { | |
| 70 // TODO(rdsmith): log this error to the net log of the URLRequest | |
| 71 // initiating this fetch, once URLRequest will be passed here. | |
| 72 SdchManager::SdchErrorRecovery( | |
| 73 SDCH_DICTIONARY_PREVIOUSLY_SCHEDULED_TO_DOWNLOAD); | |
| 74 return; | |
| 75 } | |
| 76 | |
| 77 attempted_load_.insert(dictionary_url); | |
| 78 fetch_queue_.push(dictionary_url); | |
| 79 | |
| 80 // If the loop is already processing, it'll pick up the above in the | |
| 81 // normal course of events. | |
| 82 if (next_state_ != STATE_NONE) | |
| 83 return; | |
| 84 | |
| 85 next_state_ = STATE_SEND_REQUEST; | |
| 86 | |
| 87 // There are no callbacks to user code from the dictionary fetcher, | |
| 88 // and Schedule() is only called from user code, so this call to DoLoop() | |
| 89 // does not require an |if (in_loop_) return;| guard. | |
| 90 DoLoop(OK); | |
| 91 } | |
| 92 | |
| 93 void SdchDictionaryFetcher::Cancel() { | |
| 94 DCHECK(CalledOnValidThread()); | |
| 95 | |
| 96 next_state_ = STATE_NONE; | |
| 97 | |
| 98 while (!fetch_queue_.empty()) | |
| 99 fetch_queue_.pop(); | |
| 100 attempted_load_.clear(); | |
| 101 weak_factory_.InvalidateWeakPtrs(); | |
| 102 current_request_.reset(NULL); | |
| 103 buffer_ = NULL; | |
| 104 dictionary_.clear(); | |
| 105 } | |
| 106 | |
| 107 void SdchDictionaryFetcher::OnResponseStarted(URLRequest* request) { | |
| 108 // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed. | |
| 109 tracked_objects::ScopedTracker tracking_profile( | |
| 110 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 111 "423948 SdchDictionaryFetcher::OnResponseStarted")); | |
| 112 | |
| 113 DCHECK(CalledOnValidThread()); | |
| 114 DCHECK_EQ(request, current_request_.get()); | |
| 115 DCHECK_EQ(next_state_, STATE_SEND_REQUEST_COMPLETE); | |
| 116 DCHECK(!in_loop_); | |
| 117 | |
| 118 DoLoop(request->status().error()); | |
| 119 } | |
| 120 | |
| 121 void SdchDictionaryFetcher::OnReadCompleted(URLRequest* request, | |
| 122 int bytes_read) { | |
| 123 // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed. | |
| 124 tracked_objects::ScopedTracker tracking_profile( | |
| 125 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 126 "423948 SdchDictionaryFetcher::OnReadCompleted")); | |
| 127 | |
| 128 DCHECK(CalledOnValidThread()); | |
| 129 DCHECK_EQ(request, current_request_.get()); | |
| 130 DCHECK_EQ(next_state_, STATE_READ_BODY_COMPLETE); | |
| 131 DCHECK(!in_loop_); | |
| 132 | |
| 133 DoLoop(GetReadResult(bytes_read, current_request_.get())); | |
| 134 } | |
| 135 | |
| 136 int SdchDictionaryFetcher::DoLoop(int rv) { | |
| 137 DCHECK(!in_loop_); | |
| 138 base::AutoReset<bool> auto_reset_in_loop(&in_loop_, true); | |
| 139 | |
| 140 do { | |
| 141 State state = next_state_; | |
| 142 next_state_ = STATE_NONE; | |
| 143 switch (state) { | |
| 144 case STATE_SEND_REQUEST: | |
| 145 rv = DoSendRequest(rv); | |
| 146 break; | |
| 147 case STATE_SEND_REQUEST_COMPLETE: | |
| 148 rv = DoSendRequestComplete(rv); | |
| 149 break; | |
| 150 case STATE_READ_BODY: | |
| 151 rv = DoReadBody(rv); | |
| 152 break; | |
| 153 case STATE_READ_BODY_COMPLETE: | |
| 154 rv = DoReadBodyComplete(rv); | |
| 155 break; | |
| 156 case STATE_REQUEST_COMPLETE: | |
| 157 rv = DoCompleteRequest(rv); | |
| 158 break; | |
| 159 case STATE_NONE: | |
| 160 NOTREACHED(); | |
| 161 } | |
| 162 } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); | |
| 163 | |
| 164 return rv; | |
| 165 } | |
| 166 | |
| 167 int SdchDictionaryFetcher::DoSendRequest(int rv) { | |
| 168 DCHECK(CalledOnValidThread()); | |
| 169 | |
| 170 // |rv| is ignored, as the result from the previous request doesn't | |
| 171 // affect the next request. | |
| 172 | |
| 173 if (fetch_queue_.empty() || current_request_.get()) { | |
| 174 next_state_ = STATE_NONE; | |
| 175 return OK; | |
| 176 } | |
| 177 | |
| 178 next_state_ = STATE_SEND_REQUEST_COMPLETE; | |
| 179 | |
| 180 current_request_ = | |
| 181 context_->CreateRequest(fetch_queue_.front(), IDLE, this, NULL); | |
| 182 current_request_->SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES | | |
| 183 LOAD_DO_NOT_SAVE_COOKIES); | |
| 184 buffer_ = new IOBuffer(kBufferSize); | |
| 185 fetch_queue_.pop(); | |
| 186 | |
| 187 current_request_->Start(); | |
| 188 current_request_->net_log().AddEvent(NetLog::TYPE_SDCH_DICTIONARY_FETCH); | |
| 189 | |
| 190 return ERR_IO_PENDING; | |
| 191 } | |
| 192 | |
| 193 int SdchDictionaryFetcher::DoSendRequestComplete(int rv) { | |
| 194 DCHECK(CalledOnValidThread()); | |
| 195 | |
| 196 // If there's been an error, abort the current request. | |
| 197 if (rv != OK) { | |
| 198 current_request_.reset(); | |
| 199 buffer_ = NULL; | |
| 200 next_state_ = STATE_SEND_REQUEST; | |
| 201 | |
| 202 return OK; | |
| 203 } | |
| 204 | |
| 205 next_state_ = STATE_READ_BODY; | |
| 206 return OK; | |
| 207 } | |
| 208 | |
| 209 int SdchDictionaryFetcher::DoReadBody(int rv) { | |
| 210 DCHECK(CalledOnValidThread()); | |
| 211 | |
| 212 // If there's been an error, abort the current request. | |
| 213 if (rv != OK) { | |
| 214 current_request_.reset(); | |
| 215 buffer_ = NULL; | |
| 216 next_state_ = STATE_SEND_REQUEST; | |
| 217 | |
| 218 return OK; | |
| 219 } | |
| 220 | |
| 221 next_state_ = STATE_READ_BODY_COMPLETE; | |
| 222 int bytes_read = 0; | |
| 223 current_request_->Read(buffer_.get(), kBufferSize, &bytes_read); | |
| 224 if (current_request_->status().is_io_pending()) | |
| 225 return ERR_IO_PENDING; | |
| 226 | |
| 227 return GetReadResult(bytes_read, current_request_.get()); | |
| 228 } | |
| 229 | |
| 230 int SdchDictionaryFetcher::DoReadBodyComplete(int rv) { | |
| 231 DCHECK(CalledOnValidThread()); | |
| 232 | |
| 233 // An error; abort the current request. | |
| 234 if (rv < 0) { | |
| 235 current_request_.reset(); | |
| 236 buffer_ = NULL; | |
| 237 next_state_ = STATE_SEND_REQUEST; | |
| 238 return OK; | |
| 239 } | |
| 240 | |
| 241 DCHECK(current_request_->status().is_success()); | |
| 242 | |
| 243 // Data; append to the dictionary and look for more data. | |
| 244 if (rv > 0) { | |
| 245 dictionary_.append(buffer_->data(), rv); | |
| 246 next_state_ = STATE_READ_BODY; | |
| 247 return OK; | |
| 248 } | |
| 249 | |
| 250 // End of file; complete the request. | |
| 251 next_state_ = STATE_REQUEST_COMPLETE; | |
| 252 return OK; | |
| 253 } | |
| 254 | |
| 255 int SdchDictionaryFetcher::DoCompleteRequest(int rv) { | |
| 256 DCHECK(CalledOnValidThread()); | |
| 257 | |
| 258 // DoReadBodyComplete() only transitions to this state | |
| 259 // on success. | |
| 260 DCHECK_EQ(OK, rv); | |
| 261 | |
| 262 dictionary_fetched_callback_.Run(dictionary_, current_request_->url(), | |
| 263 current_request_->net_log()); | |
| 264 current_request_.reset(); | |
| 265 buffer_ = NULL; | |
| 266 dictionary_.clear(); | |
| 267 | |
| 268 next_state_ = STATE_SEND_REQUEST; | |
| 269 | |
| 270 return OK; | |
| 271 } | |
| 272 | |
| 273 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master