| 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/disk_cache/blockfile/in_flight_backend_io.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/compiler_specific.h" | |
| 10 #include "base/logging.h" | |
| 11 #include "base/profiler/scoped_tracker.h" | |
| 12 #include "base/single_thread_task_runner.h" | |
| 13 #include "net/base/net_errors.h" | |
| 14 #include "net/disk_cache/blockfile/backend_impl.h" | |
| 15 #include "net/disk_cache/blockfile/entry_impl.h" | |
| 16 #include "net/disk_cache/blockfile/histogram_macros.h" | |
| 17 | |
| 18 // Provide a BackendImpl object to macros from histogram_macros.h. | |
| 19 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_ | |
| 20 | |
| 21 namespace disk_cache { | |
| 22 | |
| 23 BackendIO::BackendIO(InFlightIO* controller, BackendImpl* backend, | |
| 24 const net::CompletionCallback& callback) | |
| 25 : BackgroundIO(controller), | |
| 26 backend_(backend), | |
| 27 callback_(callback), | |
| 28 operation_(OP_NONE), | |
| 29 entry_ptr_(NULL), | |
| 30 iterator_(NULL), | |
| 31 entry_(NULL), | |
| 32 index_(0), | |
| 33 offset_(0), | |
| 34 buf_len_(0), | |
| 35 truncate_(false), | |
| 36 offset64_(0), | |
| 37 start_(NULL) { | |
| 38 start_time_ = base::TimeTicks::Now(); | |
| 39 } | |
| 40 | |
| 41 // Runs on the background thread. | |
| 42 void BackendIO::ExecuteOperation() { | |
| 43 if (IsEntryOperation()) | |
| 44 return ExecuteEntryOperation(); | |
| 45 | |
| 46 ExecuteBackendOperation(); | |
| 47 } | |
| 48 | |
| 49 // Runs on the background thread. | |
| 50 void BackendIO::OnIOComplete(int result) { | |
| 51 DCHECK(IsEntryOperation()); | |
| 52 DCHECK_NE(result, net::ERR_IO_PENDING); | |
| 53 result_ = result; | |
| 54 NotifyController(); | |
| 55 } | |
| 56 | |
| 57 // Runs on the primary thread. | |
| 58 void BackendIO::OnDone(bool cancel) { | |
| 59 if (IsEntryOperation()) { | |
| 60 CACHE_UMA(TIMES, "TotalIOTime", 0, ElapsedTime()); | |
| 61 } | |
| 62 | |
| 63 if (!ReturnsEntry()) | |
| 64 return; | |
| 65 | |
| 66 if (result() == net::OK) { | |
| 67 static_cast<EntryImpl*>(*entry_ptr_)->OnEntryCreated(backend_); | |
| 68 if (cancel) { | |
| 69 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is | |
| 70 // fixed. | |
| 71 tracked_objects::ScopedTracker tracking_profile( | |
| 72 FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 BackendIO::OnDone")); | |
| 73 | |
| 74 (*entry_ptr_)->Close(); | |
| 75 } | |
| 76 } | |
| 77 } | |
| 78 | |
| 79 bool BackendIO::IsEntryOperation() { | |
| 80 return operation_ > OP_MAX_BACKEND; | |
| 81 } | |
| 82 | |
| 83 // Runs on the background thread. | |
| 84 void BackendIO::ReferenceEntry() { | |
| 85 entry_->AddRef(); | |
| 86 } | |
| 87 | |
| 88 void BackendIO::Init() { | |
| 89 operation_ = OP_INIT; | |
| 90 } | |
| 91 | |
| 92 void BackendIO::OpenEntry(const std::string& key, Entry** entry) { | |
| 93 operation_ = OP_OPEN; | |
| 94 key_ = key; | |
| 95 entry_ptr_ = entry; | |
| 96 } | |
| 97 | |
| 98 void BackendIO::CreateEntry(const std::string& key, Entry** entry) { | |
| 99 operation_ = OP_CREATE; | |
| 100 key_ = key; | |
| 101 entry_ptr_ = entry; | |
| 102 } | |
| 103 | |
| 104 void BackendIO::DoomEntry(const std::string& key) { | |
| 105 operation_ = OP_DOOM; | |
| 106 key_ = key; | |
| 107 } | |
| 108 | |
| 109 void BackendIO::DoomAllEntries() { | |
| 110 operation_ = OP_DOOM_ALL; | |
| 111 } | |
| 112 | |
| 113 void BackendIO::DoomEntriesBetween(const base::Time initial_time, | |
| 114 const base::Time end_time) { | |
| 115 operation_ = OP_DOOM_BETWEEN; | |
| 116 initial_time_ = initial_time; | |
| 117 end_time_ = end_time; | |
| 118 } | |
| 119 | |
| 120 void BackendIO::DoomEntriesSince(const base::Time initial_time) { | |
| 121 operation_ = OP_DOOM_SINCE; | |
| 122 initial_time_ = initial_time; | |
| 123 } | |
| 124 | |
| 125 void BackendIO::OpenNextEntry(Rankings::Iterator* iterator, | |
| 126 Entry** next_entry) { | |
| 127 operation_ = OP_OPEN_NEXT; | |
| 128 iterator_ = iterator; | |
| 129 entry_ptr_ = next_entry; | |
| 130 } | |
| 131 | |
| 132 void BackendIO::EndEnumeration(scoped_ptr<Rankings::Iterator> iterator) { | |
| 133 operation_ = OP_END_ENUMERATION; | |
| 134 scoped_iterator_ = iterator.Pass(); | |
| 135 } | |
| 136 | |
| 137 void BackendIO::OnExternalCacheHit(const std::string& key) { | |
| 138 operation_ = OP_ON_EXTERNAL_CACHE_HIT; | |
| 139 key_ = key; | |
| 140 } | |
| 141 | |
| 142 void BackendIO::CloseEntryImpl(EntryImpl* entry) { | |
| 143 operation_ = OP_CLOSE_ENTRY; | |
| 144 entry_ = entry; | |
| 145 } | |
| 146 | |
| 147 void BackendIO::DoomEntryImpl(EntryImpl* entry) { | |
| 148 operation_ = OP_DOOM_ENTRY; | |
| 149 entry_ = entry; | |
| 150 } | |
| 151 | |
| 152 void BackendIO::FlushQueue() { | |
| 153 operation_ = OP_FLUSH_QUEUE; | |
| 154 } | |
| 155 | |
| 156 void BackendIO::RunTask(const base::Closure& task) { | |
| 157 operation_ = OP_RUN_TASK; | |
| 158 task_ = task; | |
| 159 } | |
| 160 | |
| 161 void BackendIO::ReadData(EntryImpl* entry, int index, int offset, | |
| 162 net::IOBuffer* buf, int buf_len) { | |
| 163 operation_ = OP_READ; | |
| 164 entry_ = entry; | |
| 165 index_ = index; | |
| 166 offset_ = offset; | |
| 167 buf_ = buf; | |
| 168 buf_len_ = buf_len; | |
| 169 } | |
| 170 | |
| 171 void BackendIO::WriteData(EntryImpl* entry, int index, int offset, | |
| 172 net::IOBuffer* buf, int buf_len, bool truncate) { | |
| 173 operation_ = OP_WRITE; | |
| 174 entry_ = entry; | |
| 175 index_ = index; | |
| 176 offset_ = offset; | |
| 177 buf_ = buf; | |
| 178 buf_len_ = buf_len; | |
| 179 truncate_ = truncate; | |
| 180 } | |
| 181 | |
| 182 void BackendIO::ReadSparseData(EntryImpl* entry, int64 offset, | |
| 183 net::IOBuffer* buf, int buf_len) { | |
| 184 operation_ = OP_READ_SPARSE; | |
| 185 entry_ = entry; | |
| 186 offset64_ = offset; | |
| 187 buf_ = buf; | |
| 188 buf_len_ = buf_len; | |
| 189 } | |
| 190 | |
| 191 void BackendIO::WriteSparseData(EntryImpl* entry, int64 offset, | |
| 192 net::IOBuffer* buf, int buf_len) { | |
| 193 operation_ = OP_WRITE_SPARSE; | |
| 194 entry_ = entry; | |
| 195 offset64_ = offset; | |
| 196 buf_ = buf; | |
| 197 buf_len_ = buf_len; | |
| 198 } | |
| 199 | |
| 200 void BackendIO::GetAvailableRange(EntryImpl* entry, int64 offset, int len, | |
| 201 int64* start) { | |
| 202 operation_ = OP_GET_RANGE; | |
| 203 entry_ = entry; | |
| 204 offset64_ = offset; | |
| 205 buf_len_ = len; | |
| 206 start_ = start; | |
| 207 } | |
| 208 | |
| 209 void BackendIO::CancelSparseIO(EntryImpl* entry) { | |
| 210 operation_ = OP_CANCEL_IO; | |
| 211 entry_ = entry; | |
| 212 } | |
| 213 | |
| 214 void BackendIO::ReadyForSparseIO(EntryImpl* entry) { | |
| 215 operation_ = OP_IS_READY; | |
| 216 entry_ = entry; | |
| 217 } | |
| 218 | |
| 219 BackendIO::~BackendIO() {} | |
| 220 | |
| 221 bool BackendIO::ReturnsEntry() { | |
| 222 return operation_ == OP_OPEN || operation_ == OP_CREATE || | |
| 223 operation_ == OP_OPEN_NEXT; | |
| 224 } | |
| 225 | |
| 226 base::TimeDelta BackendIO::ElapsedTime() const { | |
| 227 return base::TimeTicks::Now() - start_time_; | |
| 228 } | |
| 229 | |
| 230 // Runs on the background thread. | |
| 231 void BackendIO::ExecuteBackendOperation() { | |
| 232 switch (operation_) { | |
| 233 case OP_INIT: | |
| 234 result_ = backend_->SyncInit(); | |
| 235 break; | |
| 236 case OP_OPEN: | |
| 237 result_ = backend_->SyncOpenEntry(key_, entry_ptr_); | |
| 238 break; | |
| 239 case OP_CREATE: | |
| 240 result_ = backend_->SyncCreateEntry(key_, entry_ptr_); | |
| 241 break; | |
| 242 case OP_DOOM: | |
| 243 result_ = backend_->SyncDoomEntry(key_); | |
| 244 break; | |
| 245 case OP_DOOM_ALL: | |
| 246 result_ = backend_->SyncDoomAllEntries(); | |
| 247 break; | |
| 248 case OP_DOOM_BETWEEN: | |
| 249 result_ = backend_->SyncDoomEntriesBetween(initial_time_, end_time_); | |
| 250 break; | |
| 251 case OP_DOOM_SINCE: | |
| 252 result_ = backend_->SyncDoomEntriesSince(initial_time_); | |
| 253 break; | |
| 254 case OP_OPEN_NEXT: | |
| 255 result_ = backend_->SyncOpenNextEntry(iterator_, entry_ptr_); | |
| 256 break; | |
| 257 case OP_END_ENUMERATION: | |
| 258 backend_->SyncEndEnumeration(scoped_iterator_.Pass()); | |
| 259 result_ = net::OK; | |
| 260 break; | |
| 261 case OP_ON_EXTERNAL_CACHE_HIT: | |
| 262 backend_->SyncOnExternalCacheHit(key_); | |
| 263 result_ = net::OK; | |
| 264 break; | |
| 265 case OP_CLOSE_ENTRY: | |
| 266 entry_->Release(); | |
| 267 result_ = net::OK; | |
| 268 break; | |
| 269 case OP_DOOM_ENTRY: | |
| 270 entry_->DoomImpl(); | |
| 271 result_ = net::OK; | |
| 272 break; | |
| 273 case OP_FLUSH_QUEUE: | |
| 274 result_ = net::OK; | |
| 275 break; | |
| 276 case OP_RUN_TASK: | |
| 277 task_.Run(); | |
| 278 result_ = net::OK; | |
| 279 break; | |
| 280 default: | |
| 281 NOTREACHED() << "Invalid Operation"; | |
| 282 result_ = net::ERR_UNEXPECTED; | |
| 283 } | |
| 284 DCHECK_NE(net::ERR_IO_PENDING, result_); | |
| 285 NotifyController(); | |
| 286 } | |
| 287 | |
| 288 // Runs on the background thread. | |
| 289 void BackendIO::ExecuteEntryOperation() { | |
| 290 switch (operation_) { | |
| 291 case OP_READ: | |
| 292 result_ = | |
| 293 entry_->ReadDataImpl(index_, offset_, buf_.get(), buf_len_, | |
| 294 base::Bind(&BackendIO::OnIOComplete, this)); | |
| 295 break; | |
| 296 case OP_WRITE: | |
| 297 result_ = | |
| 298 entry_->WriteDataImpl(index_, offset_, buf_.get(), buf_len_, | |
| 299 base::Bind(&BackendIO::OnIOComplete, this), | |
| 300 truncate_); | |
| 301 break; | |
| 302 case OP_READ_SPARSE: | |
| 303 result_ = entry_->ReadSparseDataImpl( | |
| 304 offset64_, buf_.get(), buf_len_, | |
| 305 base::Bind(&BackendIO::OnIOComplete, this)); | |
| 306 break; | |
| 307 case OP_WRITE_SPARSE: | |
| 308 result_ = entry_->WriteSparseDataImpl( | |
| 309 offset64_, buf_.get(), buf_len_, | |
| 310 base::Bind(&BackendIO::OnIOComplete, this)); | |
| 311 break; | |
| 312 case OP_GET_RANGE: | |
| 313 result_ = entry_->GetAvailableRangeImpl(offset64_, buf_len_, start_); | |
| 314 break; | |
| 315 case OP_CANCEL_IO: | |
| 316 entry_->CancelSparseIOImpl(); | |
| 317 result_ = net::OK; | |
| 318 break; | |
| 319 case OP_IS_READY: | |
| 320 result_ = entry_->ReadyForSparseIOImpl( | |
| 321 base::Bind(&BackendIO::OnIOComplete, this)); | |
| 322 break; | |
| 323 default: | |
| 324 NOTREACHED() << "Invalid Operation"; | |
| 325 result_ = net::ERR_UNEXPECTED; | |
| 326 } | |
| 327 buf_ = NULL; | |
| 328 if (result_ != net::ERR_IO_PENDING) | |
| 329 NotifyController(); | |
| 330 } | |
| 331 | |
| 332 InFlightBackendIO::InFlightBackendIO( | |
| 333 BackendImpl* backend, | |
| 334 const scoped_refptr<base::SingleThreadTaskRunner>& background_thread) | |
| 335 : backend_(backend), | |
| 336 background_thread_(background_thread), | |
| 337 ptr_factory_(this) { | |
| 338 } | |
| 339 | |
| 340 InFlightBackendIO::~InFlightBackendIO() { | |
| 341 } | |
| 342 | |
| 343 void InFlightBackendIO::Init(const net::CompletionCallback& callback) { | |
| 344 // TODO(vadimt): Remove wrapping the callback with | |
| 345 // ScopedTracker::TrackCallback() once crbug.com/422516 is fixed. | |
| 346 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 347 this, backend_, | |
| 348 tracked_objects::ScopedTracker::TrackCallback( | |
| 349 FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 InFlightBackendIO::Init"), | |
| 350 callback))); | |
| 351 operation->Init(); | |
| 352 PostOperation(operation.get()); | |
| 353 } | |
| 354 | |
| 355 void InFlightBackendIO::OpenEntry(const std::string& key, Entry** entry, | |
| 356 const net::CompletionCallback& callback) { | |
| 357 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 358 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 359 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 360 "422516 InFlightBackendIO::OpenEntry"), | |
| 361 callback))); | |
| 362 operation->OpenEntry(key, entry); | |
| 363 PostOperation(operation.get()); | |
| 364 } | |
| 365 | |
| 366 void InFlightBackendIO::CreateEntry(const std::string& key, Entry** entry, | |
| 367 const net::CompletionCallback& callback) { | |
| 368 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 369 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 370 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 371 "422516 InFlightBackendIO::CreateEntry"), | |
| 372 callback))); | |
| 373 operation->CreateEntry(key, entry); | |
| 374 PostOperation(operation.get()); | |
| 375 } | |
| 376 | |
| 377 void InFlightBackendIO::DoomEntry(const std::string& key, | |
| 378 const net::CompletionCallback& callback) { | |
| 379 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 380 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 381 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 382 "422516 InFlightBackendIO::DoomEntry"), | |
| 383 callback))); | |
| 384 operation->DoomEntry(key); | |
| 385 PostOperation(operation.get()); | |
| 386 } | |
| 387 | |
| 388 void InFlightBackendIO::DoomAllEntries( | |
| 389 const net::CompletionCallback& callback) { | |
| 390 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 391 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 392 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 393 "422516 InFlightBackendIO::DoomAllEntries"), | |
| 394 callback))); | |
| 395 operation->DoomAllEntries(); | |
| 396 PostOperation(operation.get()); | |
| 397 } | |
| 398 | |
| 399 void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time, | |
| 400 const base::Time end_time, | |
| 401 const net::CompletionCallback& callback) { | |
| 402 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 403 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 404 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 405 "422516 InFlightBackendIO::DoomEntriesBetween"), | |
| 406 callback))); | |
| 407 operation->DoomEntriesBetween(initial_time, end_time); | |
| 408 PostOperation(operation.get()); | |
| 409 } | |
| 410 | |
| 411 void InFlightBackendIO::DoomEntriesSince( | |
| 412 const base::Time initial_time, const net::CompletionCallback& callback) { | |
| 413 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 414 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 415 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 416 "422516 InFlightBackendIO::DoomEntriesSince"), | |
| 417 callback))); | |
| 418 operation->DoomEntriesSince(initial_time); | |
| 419 PostOperation(operation.get()); | |
| 420 } | |
| 421 | |
| 422 void InFlightBackendIO::OpenNextEntry(Rankings::Iterator* iterator, | |
| 423 Entry** next_entry, | |
| 424 const net::CompletionCallback& callback) { | |
| 425 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 426 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 427 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 428 "422516 InFlightBackendIO::OpenNextEntry"), | |
| 429 callback))); | |
| 430 operation->OpenNextEntry(iterator, next_entry); | |
| 431 PostOperation(operation.get()); | |
| 432 } | |
| 433 | |
| 434 void InFlightBackendIO::EndEnumeration( | |
| 435 scoped_ptr<Rankings::Iterator> iterator) { | |
| 436 scoped_refptr<BackendIO> operation( | |
| 437 new BackendIO(this, backend_, net::CompletionCallback())); | |
| 438 operation->EndEnumeration(iterator.Pass()); | |
| 439 PostOperation(operation.get()); | |
| 440 } | |
| 441 | |
| 442 void InFlightBackendIO::OnExternalCacheHit(const std::string& key) { | |
| 443 scoped_refptr<BackendIO> operation( | |
| 444 new BackendIO(this, backend_, net::CompletionCallback())); | |
| 445 operation->OnExternalCacheHit(key); | |
| 446 PostOperation(operation.get()); | |
| 447 } | |
| 448 | |
| 449 void InFlightBackendIO::CloseEntryImpl(EntryImpl* entry) { | |
| 450 scoped_refptr<BackendIO> operation( | |
| 451 new BackendIO(this, backend_, net::CompletionCallback())); | |
| 452 operation->CloseEntryImpl(entry); | |
| 453 PostOperation(operation.get()); | |
| 454 } | |
| 455 | |
| 456 void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) { | |
| 457 scoped_refptr<BackendIO> operation( | |
| 458 new BackendIO(this, backend_, net::CompletionCallback())); | |
| 459 operation->DoomEntryImpl(entry); | |
| 460 PostOperation(operation.get()); | |
| 461 } | |
| 462 | |
| 463 void InFlightBackendIO::FlushQueue(const net::CompletionCallback& callback) { | |
| 464 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 465 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 466 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 467 "422516 InFlightBackendIO::FlushQueue"), | |
| 468 callback))); | |
| 469 operation->FlushQueue(); | |
| 470 PostOperation(operation.get()); | |
| 471 } | |
| 472 | |
| 473 void InFlightBackendIO::RunTask( | |
| 474 const base::Closure& task, const net::CompletionCallback& callback) { | |
| 475 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 476 this, backend_, | |
| 477 tracked_objects::ScopedTracker::TrackCallback( | |
| 478 FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 InFlightBackendIO::RunTask"), | |
| 479 callback))); | |
| 480 operation->RunTask(task); | |
| 481 PostOperation(operation.get()); | |
| 482 } | |
| 483 | |
| 484 void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset, | |
| 485 net::IOBuffer* buf, int buf_len, | |
| 486 const net::CompletionCallback& callback) { | |
| 487 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 488 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 489 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 490 "422516 InFlightBackendIO::ReadData"), | |
| 491 callback))); | |
| 492 operation->ReadData(entry, index, offset, buf, buf_len); | |
| 493 PostOperation(operation.get()); | |
| 494 } | |
| 495 | |
| 496 void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset, | |
| 497 net::IOBuffer* buf, int buf_len, | |
| 498 bool truncate, | |
| 499 const net::CompletionCallback& callback) { | |
| 500 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 501 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 502 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 503 "422516 InFlightBackendIO::WriteData"), | |
| 504 callback))); | |
| 505 operation->WriteData(entry, index, offset, buf, buf_len, truncate); | |
| 506 PostOperation(operation.get()); | |
| 507 } | |
| 508 | |
| 509 void InFlightBackendIO::ReadSparseData( | |
| 510 EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len, | |
| 511 const net::CompletionCallback& callback) { | |
| 512 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 513 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 514 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 515 "422516 InFlightBackendIO::ReadSparseData"), | |
| 516 callback))); | |
| 517 operation->ReadSparseData(entry, offset, buf, buf_len); | |
| 518 PostOperation(operation.get()); | |
| 519 } | |
| 520 | |
| 521 void InFlightBackendIO::WriteSparseData( | |
| 522 EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len, | |
| 523 const net::CompletionCallback& callback) { | |
| 524 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 525 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 526 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 527 "422516 InFlightBackendIO::WriteSparseData"), | |
| 528 callback))); | |
| 529 operation->WriteSparseData(entry, offset, buf, buf_len); | |
| 530 PostOperation(operation.get()); | |
| 531 } | |
| 532 | |
| 533 void InFlightBackendIO::GetAvailableRange( | |
| 534 EntryImpl* entry, int64 offset, int len, int64* start, | |
| 535 const net::CompletionCallback& callback) { | |
| 536 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 537 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 538 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 539 "422516 InFlightBackendIO::GetAvailableRange"), | |
| 540 callback))); | |
| 541 operation->GetAvailableRange(entry, offset, len, start); | |
| 542 PostOperation(operation.get()); | |
| 543 } | |
| 544 | |
| 545 void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) { | |
| 546 scoped_refptr<BackendIO> operation( | |
| 547 new BackendIO(this, backend_, net::CompletionCallback())); | |
| 548 operation->CancelSparseIO(entry); | |
| 549 PostOperation(operation.get()); | |
| 550 } | |
| 551 | |
| 552 void InFlightBackendIO::ReadyForSparseIO( | |
| 553 EntryImpl* entry, const net::CompletionCallback& callback) { | |
| 554 scoped_refptr<BackendIO> operation(new BackendIO( | |
| 555 this, backend_, tracked_objects::ScopedTracker::TrackCallback( | |
| 556 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 557 "422516 InFlightBackendIO::CancelSparseIO"), | |
| 558 callback))); | |
| 559 operation->ReadyForSparseIO(entry); | |
| 560 PostOperation(operation.get()); | |
| 561 } | |
| 562 | |
| 563 void InFlightBackendIO::WaitForPendingIO() { | |
| 564 InFlightIO::WaitForPendingIO(); | |
| 565 } | |
| 566 | |
| 567 void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation, | |
| 568 bool cancel) { | |
| 569 BackendIO* op = static_cast<BackendIO*>(operation); | |
| 570 op->OnDone(cancel); | |
| 571 | |
| 572 if (!op->callback().is_null() && (!cancel || op->IsEntryOperation())) { | |
| 573 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 574 tracked_objects::ScopedTracker tracking_profile( | |
| 575 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 576 "422516 InFlightBackendIO::OnOperationComplete")); | |
| 577 | |
| 578 op->callback().Run(op->result()); | |
| 579 } | |
| 580 } | |
| 581 | |
| 582 void InFlightBackendIO::PostOperation(BackendIO* operation) { | |
| 583 background_thread_->PostTask( | |
| 584 FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation)); | |
| 585 OnOperationPosted(operation); | |
| 586 } | |
| 587 | |
| 588 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() { | |
| 589 return ptr_factory_.GetWeakPtr(); | |
| 590 } | |
| 591 | |
| 592 } // namespace | |
| 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