| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/http/partial_data.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/format_macros.h" | |
| 10 #include "base/logging.h" | |
| 11 #include "base/profiler/scoped_tracker.h" | |
| 12 #include "base/strings/string_number_conversions.h" | |
| 13 #include "base/strings/string_util.h" | |
| 14 #include "base/strings/stringprintf.h" | |
| 15 #include "net/base/net_errors.h" | |
| 16 #include "net/disk_cache/disk_cache.h" | |
| 17 #include "net/http/http_response_headers.h" | |
| 18 #include "net/http/http_util.h" | |
| 19 | |
| 20 namespace net { | |
| 21 | |
| 22 namespace { | |
| 23 | |
| 24 // The headers that we have to process. | |
| 25 const char kLengthHeader[] = "Content-Length"; | |
| 26 const char kRangeHeader[] = "Content-Range"; | |
| 27 const int kDataStream = 1; | |
| 28 | |
| 29 } // namespace | |
| 30 | |
| 31 // A core object that can be detached from the Partialdata object at destruction | |
| 32 // so that asynchronous operations cleanup can be performed. | |
| 33 class PartialData::Core { | |
| 34 public: | |
| 35 // Build a new core object. Lifetime management is automatic. | |
| 36 static Core* CreateCore(PartialData* owner) { | |
| 37 return new Core(owner); | |
| 38 } | |
| 39 | |
| 40 // Wrapper for Entry::GetAvailableRange. If this method returns ERR_IO_PENDING | |
| 41 // PartialData::GetAvailableRangeCompleted() will be invoked on the owner | |
| 42 // object when finished (unless Cancel() is called first). | |
| 43 int GetAvailableRange(disk_cache::Entry* entry, int64 offset, int len, | |
| 44 int64* start); | |
| 45 | |
| 46 // Cancels a pending operation. It is a mistake to call this method if there | |
| 47 // is no operation in progress; in fact, there will be no object to do so. | |
| 48 void Cancel(); | |
| 49 | |
| 50 private: | |
| 51 explicit Core(PartialData* owner); | |
| 52 ~Core(); | |
| 53 | |
| 54 // Pending io completion routine. | |
| 55 void OnIOComplete(int result); | |
| 56 | |
| 57 PartialData* owner_; | |
| 58 int64 start_; | |
| 59 | |
| 60 DISALLOW_COPY_AND_ASSIGN(Core); | |
| 61 }; | |
| 62 | |
| 63 PartialData::Core::Core(PartialData* owner) | |
| 64 : owner_(owner), start_(0) { | |
| 65 DCHECK(!owner_->core_); | |
| 66 owner_->core_ = this; | |
| 67 } | |
| 68 | |
| 69 PartialData::Core::~Core() { | |
| 70 if (owner_) | |
| 71 owner_->core_ = NULL; | |
| 72 } | |
| 73 | |
| 74 void PartialData::Core::Cancel() { | |
| 75 DCHECK(owner_); | |
| 76 owner_ = NULL; | |
| 77 } | |
| 78 | |
| 79 int PartialData::Core::GetAvailableRange(disk_cache::Entry* entry, int64 offset, | |
| 80 int len, int64* start) { | |
| 81 int rv = entry->GetAvailableRange( | |
| 82 offset, len, &start_, base::Bind(&PartialData::Core::OnIOComplete, | |
| 83 base::Unretained(this))); | |
| 84 if (rv != net::ERR_IO_PENDING) { | |
| 85 // The callback will not be invoked. Lets cleanup. | |
| 86 *start = start_; | |
| 87 delete this; | |
| 88 } | |
| 89 return rv; | |
| 90 } | |
| 91 | |
| 92 void PartialData::Core::OnIOComplete(int result) { | |
| 93 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 94 tracked_objects::ScopedTracker tracking_profile( | |
| 95 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 96 "422516 PartialData::Core::OnIOComplete")); | |
| 97 | |
| 98 if (owner_) | |
| 99 owner_->GetAvailableRangeCompleted(result, start_); | |
| 100 delete this; | |
| 101 } | |
| 102 | |
| 103 // ----------------------------------------------------------------------------- | |
| 104 | |
| 105 PartialData::PartialData() | |
| 106 : current_range_start_(0), | |
| 107 current_range_end_(0), | |
| 108 cached_start_(0), | |
| 109 resource_size_(0), | |
| 110 cached_min_len_(0), | |
| 111 range_present_(false), | |
| 112 final_range_(false), | |
| 113 sparse_entry_(true), | |
| 114 truncated_(false), | |
| 115 initial_validation_(false), | |
| 116 core_(NULL) { | |
| 117 } | |
| 118 | |
| 119 PartialData::~PartialData() { | |
| 120 if (core_) | |
| 121 core_->Cancel(); | |
| 122 } | |
| 123 | |
| 124 bool PartialData::Init(const HttpRequestHeaders& headers) { | |
| 125 std::string range_header; | |
| 126 if (!headers.GetHeader(HttpRequestHeaders::kRange, &range_header)) | |
| 127 return false; | |
| 128 | |
| 129 std::vector<HttpByteRange> ranges; | |
| 130 if (!HttpUtil::ParseRangeHeader(range_header, &ranges) || ranges.size() != 1) | |
| 131 return false; | |
| 132 | |
| 133 // We can handle this range request. | |
| 134 byte_range_ = ranges[0]; | |
| 135 if (!byte_range_.IsValid()) | |
| 136 return false; | |
| 137 | |
| 138 current_range_start_ = byte_range_.first_byte_position(); | |
| 139 | |
| 140 DVLOG(1) << "Range start: " << current_range_start_ << " end: " << | |
| 141 byte_range_.last_byte_position(); | |
| 142 return true; | |
| 143 } | |
| 144 | |
| 145 void PartialData::SetHeaders(const HttpRequestHeaders& headers) { | |
| 146 DCHECK(extra_headers_.IsEmpty()); | |
| 147 extra_headers_.CopyFrom(headers); | |
| 148 } | |
| 149 | |
| 150 void PartialData::RestoreHeaders(HttpRequestHeaders* headers) const { | |
| 151 DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange()); | |
| 152 int64 end = byte_range_.IsSuffixByteRange() ? | |
| 153 byte_range_.suffix_length() : byte_range_.last_byte_position(); | |
| 154 | |
| 155 headers->CopyFrom(extra_headers_); | |
| 156 if (truncated_ || !byte_range_.IsValid()) | |
| 157 return; | |
| 158 | |
| 159 if (current_range_start_ < 0) { | |
| 160 headers->SetHeader(HttpRequestHeaders::kRange, | |
| 161 HttpByteRange::Suffix(end).GetHeaderValue()); | |
| 162 } else { | |
| 163 headers->SetHeader(HttpRequestHeaders::kRange, | |
| 164 HttpByteRange::Bounded( | |
| 165 current_range_start_, end).GetHeaderValue()); | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 int PartialData::ShouldValidateCache(disk_cache::Entry* entry, | |
| 170 const CompletionCallback& callback) { | |
| 171 DCHECK_GE(current_range_start_, 0); | |
| 172 | |
| 173 // Scan the disk cache for the first cached portion within this range. | |
| 174 int len = GetNextRangeLen(); | |
| 175 if (!len) | |
| 176 return 0; | |
| 177 | |
| 178 DVLOG(3) << "ShouldValidateCache len: " << len; | |
| 179 | |
| 180 if (sparse_entry_) { | |
| 181 DCHECK(callback_.is_null()); | |
| 182 Core* core = Core::CreateCore(this); | |
| 183 cached_min_len_ = core->GetAvailableRange(entry, current_range_start_, len, | |
| 184 &cached_start_); | |
| 185 | |
| 186 if (cached_min_len_ == ERR_IO_PENDING) { | |
| 187 callback_ = callback; | |
| 188 return ERR_IO_PENDING; | |
| 189 } | |
| 190 } else if (!truncated_) { | |
| 191 if (byte_range_.HasFirstBytePosition() && | |
| 192 byte_range_.first_byte_position() >= resource_size_) { | |
| 193 // The caller should take care of this condition because we should have | |
| 194 // failed IsRequestedRangeOK(), but it's better to be consistent here. | |
| 195 len = 0; | |
| 196 } | |
| 197 cached_min_len_ = len; | |
| 198 cached_start_ = current_range_start_; | |
| 199 } | |
| 200 | |
| 201 if (cached_min_len_ < 0) | |
| 202 return cached_min_len_; | |
| 203 | |
| 204 // Return a positive number to indicate success (versus error or finished). | |
| 205 return 1; | |
| 206 } | |
| 207 | |
| 208 void PartialData::PrepareCacheValidation(disk_cache::Entry* entry, | |
| 209 HttpRequestHeaders* headers) { | |
| 210 DCHECK_GE(current_range_start_, 0); | |
| 211 DCHECK_GE(cached_min_len_, 0); | |
| 212 | |
| 213 int len = GetNextRangeLen(); | |
| 214 DCHECK_NE(0, len); | |
| 215 range_present_ = false; | |
| 216 | |
| 217 headers->CopyFrom(extra_headers_); | |
| 218 | |
| 219 if (!cached_min_len_) { | |
| 220 // We don't have anything else stored. | |
| 221 final_range_ = true; | |
| 222 cached_start_ = | |
| 223 byte_range_.HasLastBytePosition() ? current_range_start_ + len : 0; | |
| 224 } | |
| 225 | |
| 226 if (current_range_start_ == cached_start_) { | |
| 227 // The data lives in the cache. | |
| 228 range_present_ = true; | |
| 229 current_range_end_ = cached_start_ + cached_min_len_ - 1; | |
| 230 if (len == cached_min_len_) | |
| 231 final_range_ = true; | |
| 232 headers->SetHeader( | |
| 233 HttpRequestHeaders::kRange, | |
| 234 HttpByteRange::Bounded(current_range_start_, current_range_end_) | |
| 235 .GetHeaderValue()); | |
| 236 } else { | |
| 237 // This range is not in the cache. | |
| 238 current_range_end_ = cached_start_ - 1; | |
| 239 headers->SetHeader( | |
| 240 HttpRequestHeaders::kRange, | |
| 241 HttpByteRange::Bounded(current_range_start_, current_range_end_) | |
| 242 .GetHeaderValue()); | |
| 243 } | |
| 244 } | |
| 245 | |
| 246 bool PartialData::IsCurrentRangeCached() const { | |
| 247 return range_present_; | |
| 248 } | |
| 249 | |
| 250 bool PartialData::IsLastRange() const { | |
| 251 return final_range_; | |
| 252 } | |
| 253 | |
| 254 bool PartialData::UpdateFromStoredHeaders(const HttpResponseHeaders* headers, | |
| 255 disk_cache::Entry* entry, | |
| 256 bool truncated) { | |
| 257 resource_size_ = 0; | |
| 258 if (truncated) { | |
| 259 DCHECK_EQ(headers->response_code(), 200); | |
| 260 // We don't have the real length and the user may be trying to create a | |
| 261 // sparse entry so let's not write to this entry. | |
| 262 if (byte_range_.IsValid()) | |
| 263 return false; | |
| 264 | |
| 265 if (!headers->HasStrongValidators()) | |
| 266 return false; | |
| 267 | |
| 268 // Now we avoid resume if there is no content length, but that was not | |
| 269 // always the case so double check here. | |
| 270 int64 total_length = headers->GetContentLength(); | |
| 271 if (total_length <= 0) | |
| 272 return false; | |
| 273 | |
| 274 truncated_ = true; | |
| 275 initial_validation_ = true; | |
| 276 sparse_entry_ = false; | |
| 277 int current_len = entry->GetDataSize(kDataStream); | |
| 278 byte_range_.set_first_byte_position(current_len); | |
| 279 resource_size_ = total_length; | |
| 280 current_range_start_ = current_len; | |
| 281 cached_min_len_ = current_len; | |
| 282 cached_start_ = current_len + 1; | |
| 283 return true; | |
| 284 } | |
| 285 | |
| 286 if (headers->response_code() != 206) { | |
| 287 DCHECK(byte_range_.IsValid()); | |
| 288 sparse_entry_ = false; | |
| 289 resource_size_ = entry->GetDataSize(kDataStream); | |
| 290 DVLOG(2) << "UpdateFromStoredHeaders size: " << resource_size_; | |
| 291 return true; | |
| 292 } | |
| 293 | |
| 294 if (!headers->HasStrongValidators()) | |
| 295 return false; | |
| 296 | |
| 297 int64 length_value = headers->GetContentLength(); | |
| 298 if (length_value <= 0) | |
| 299 return false; // We must have stored the resource length. | |
| 300 | |
| 301 resource_size_ = length_value; | |
| 302 | |
| 303 // Make sure that this is really a sparse entry. | |
| 304 return entry->CouldBeSparse(); | |
| 305 } | |
| 306 | |
| 307 void PartialData::SetRangeToStartDownload() { | |
| 308 DCHECK(truncated_); | |
| 309 DCHECK(!sparse_entry_); | |
| 310 current_range_start_ = 0; | |
| 311 cached_start_ = 0; | |
| 312 initial_validation_ = false; | |
| 313 } | |
| 314 | |
| 315 bool PartialData::IsRequestedRangeOK() { | |
| 316 if (byte_range_.IsValid()) { | |
| 317 if (!byte_range_.ComputeBounds(resource_size_)) | |
| 318 return false; | |
| 319 if (truncated_) | |
| 320 return true; | |
| 321 | |
| 322 if (current_range_start_ < 0) | |
| 323 current_range_start_ = byte_range_.first_byte_position(); | |
| 324 } else { | |
| 325 // This is not a range request but we have partial data stored. | |
| 326 current_range_start_ = 0; | |
| 327 byte_range_.set_last_byte_position(resource_size_ - 1); | |
| 328 } | |
| 329 | |
| 330 bool rv = current_range_start_ >= 0; | |
| 331 if (!rv) | |
| 332 current_range_start_ = 0; | |
| 333 | |
| 334 return rv; | |
| 335 } | |
| 336 | |
| 337 bool PartialData::ResponseHeadersOK(const HttpResponseHeaders* headers) { | |
| 338 if (headers->response_code() == 304) { | |
| 339 if (!byte_range_.IsValid() || truncated_) | |
| 340 return true; | |
| 341 | |
| 342 // We must have a complete range here. | |
| 343 return byte_range_.HasFirstBytePosition() && | |
| 344 byte_range_.HasLastBytePosition(); | |
| 345 } | |
| 346 | |
| 347 int64 start, end, total_length; | |
| 348 if (!headers->GetContentRange(&start, &end, &total_length)) | |
| 349 return false; | |
| 350 if (total_length <= 0) | |
| 351 return false; | |
| 352 | |
| 353 DCHECK_EQ(headers->response_code(), 206); | |
| 354 | |
| 355 // A server should return a valid content length with a 206 (per the standard) | |
| 356 // but relax the requirement because some servers don't do that. | |
| 357 int64 content_length = headers->GetContentLength(); | |
| 358 if (content_length > 0 && content_length != end - start + 1) | |
| 359 return false; | |
| 360 | |
| 361 if (!resource_size_) { | |
| 362 // First response. Update our values with the ones provided by the server. | |
| 363 resource_size_ = total_length; | |
| 364 if (!byte_range_.HasFirstBytePosition()) { | |
| 365 byte_range_.set_first_byte_position(start); | |
| 366 current_range_start_ = start; | |
| 367 } | |
| 368 if (!byte_range_.HasLastBytePosition()) | |
| 369 byte_range_.set_last_byte_position(end); | |
| 370 } else if (resource_size_ != total_length) { | |
| 371 return false; | |
| 372 } | |
| 373 | |
| 374 if (truncated_) { | |
| 375 if (!byte_range_.HasLastBytePosition()) | |
| 376 byte_range_.set_last_byte_position(end); | |
| 377 } | |
| 378 | |
| 379 if (start != current_range_start_) | |
| 380 return false; | |
| 381 | |
| 382 if (!current_range_end_) { | |
| 383 // There is nothing in the cache. | |
| 384 DCHECK(byte_range_.HasLastBytePosition()); | |
| 385 current_range_end_ = byte_range_.last_byte_position(); | |
| 386 if (current_range_end_ >= resource_size_) { | |
| 387 // We didn't know the real file size, and the server is saying that the | |
| 388 // requested range goes beyond the size. Fix it. | |
| 389 current_range_end_ = end; | |
| 390 byte_range_.set_last_byte_position(end); | |
| 391 } | |
| 392 } | |
| 393 | |
| 394 // If we received a range, but it's not exactly the range we asked for, avoid | |
| 395 // trouble and signal an error. | |
| 396 if (end != current_range_end_) | |
| 397 return false; | |
| 398 | |
| 399 return true; | |
| 400 } | |
| 401 | |
| 402 // We are making multiple requests to complete the range requested by the user. | |
| 403 // Just assume that everything is fine and say that we are returning what was | |
| 404 // requested. | |
| 405 void PartialData::FixResponseHeaders(HttpResponseHeaders* headers, | |
| 406 bool success) { | |
| 407 if (truncated_) | |
| 408 return; | |
| 409 | |
| 410 if (byte_range_.IsValid() && success) { | |
| 411 headers->UpdateWithNewRange(byte_range_, resource_size_, !sparse_entry_); | |
| 412 return; | |
| 413 } | |
| 414 | |
| 415 headers->RemoveHeader(kLengthHeader); | |
| 416 headers->RemoveHeader(kRangeHeader); | |
| 417 | |
| 418 if (byte_range_.IsValid()) { | |
| 419 headers->ReplaceStatusLine("HTTP/1.1 416 Requested Range Not Satisfiable"); | |
| 420 headers->AddHeader(base::StringPrintf("%s: bytes 0-0/%" PRId64, | |
| 421 kRangeHeader, resource_size_)); | |
| 422 headers->AddHeader(base::StringPrintf("%s: 0", kLengthHeader)); | |
| 423 } else { | |
| 424 // TODO(rvargas): Is it safe to change the protocol version? | |
| 425 headers->ReplaceStatusLine("HTTP/1.1 200 OK"); | |
| 426 DCHECK_NE(resource_size_, 0); | |
| 427 headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader, | |
| 428 resource_size_)); | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 void PartialData::FixContentLength(HttpResponseHeaders* headers) { | |
| 433 headers->RemoveHeader(kLengthHeader); | |
| 434 headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader, | |
| 435 resource_size_)); | |
| 436 } | |
| 437 | |
| 438 int PartialData::CacheRead( | |
| 439 disk_cache::Entry* entry, IOBuffer* data, int data_len, | |
| 440 const net::CompletionCallback& callback) { | |
| 441 int read_len = std::min(data_len, cached_min_len_); | |
| 442 if (!read_len) | |
| 443 return 0; | |
| 444 | |
| 445 int rv = 0; | |
| 446 if (sparse_entry_) { | |
| 447 rv = entry->ReadSparseData(current_range_start_, data, read_len, | |
| 448 callback); | |
| 449 } else { | |
| 450 if (current_range_start_ > kint32max) | |
| 451 return ERR_INVALID_ARGUMENT; | |
| 452 | |
| 453 rv = entry->ReadData(kDataStream, static_cast<int>(current_range_start_), | |
| 454 data, read_len, callback); | |
| 455 } | |
| 456 return rv; | |
| 457 } | |
| 458 | |
| 459 int PartialData::CacheWrite( | |
| 460 disk_cache::Entry* entry, IOBuffer* data, int data_len, | |
| 461 const net::CompletionCallback& callback) { | |
| 462 DVLOG(3) << "To write: " << data_len; | |
| 463 if (sparse_entry_) { | |
| 464 return entry->WriteSparseData( | |
| 465 current_range_start_, data, data_len, callback); | |
| 466 } else { | |
| 467 if (current_range_start_ > kint32max) | |
| 468 return ERR_INVALID_ARGUMENT; | |
| 469 | |
| 470 return entry->WriteData(kDataStream, static_cast<int>(current_range_start_), | |
| 471 data, data_len, callback, true); | |
| 472 } | |
| 473 } | |
| 474 | |
| 475 void PartialData::OnCacheReadCompleted(int result) { | |
| 476 DVLOG(3) << "Read: " << result; | |
| 477 if (result > 0) { | |
| 478 current_range_start_ += result; | |
| 479 cached_min_len_ -= result; | |
| 480 DCHECK_GE(cached_min_len_, 0); | |
| 481 } | |
| 482 } | |
| 483 | |
| 484 void PartialData::OnNetworkReadCompleted(int result) { | |
| 485 if (result > 0) | |
| 486 current_range_start_ += result; | |
| 487 } | |
| 488 | |
| 489 int PartialData::GetNextRangeLen() { | |
| 490 int64 range_len = | |
| 491 byte_range_.HasLastBytePosition() ? | |
| 492 byte_range_.last_byte_position() - current_range_start_ + 1 : | |
| 493 kint32max; | |
| 494 if (range_len > kint32max) | |
| 495 range_len = kint32max; | |
| 496 return static_cast<int32>(range_len); | |
| 497 } | |
| 498 | |
| 499 void PartialData::GetAvailableRangeCompleted(int result, int64 start) { | |
| 500 DCHECK(!callback_.is_null()); | |
| 501 DCHECK_NE(ERR_IO_PENDING, result); | |
| 502 | |
| 503 cached_start_ = start; | |
| 504 cached_min_len_ = result; | |
| 505 if (result >= 0) | |
| 506 result = 1; // Return success, go ahead and validate the entry. | |
| 507 | |
| 508 CompletionCallback cb = callback_; | |
| 509 callback_.Reset(); | |
| 510 cb.Run(result); | |
| 511 } | |
| 512 | |
| 513 } // 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