net/http/disk_cache_based_quic_server_info.cc

   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/http/disk_cache_based_quic_server_info.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/logging.h"
  10 #include "net/base/completion_callback.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/http/http_cache.h"
  14 #include "net/http/http_network_session.h"
  15 #include "net/quic/quic_server_id.h"
  16
  17 namespace net {
  18
  19 // Some APIs inside disk_cache take a handle that the caller must keep alive
  20 // until the API has finished its asynchronous execution.
  21 //
  22 // Unfortunately, DiskCacheBasedQuicServerInfo may be deleted before the
  23 // operation completes causing a use-after-free.
  24 //
  25 // This data shim struct is meant to provide a location for the disk_cache
  26 // APIs to write into even if the originating DiskCacheBasedQuicServerInfo
  27 // object has been deleted.  The lifetime for instances of this struct
  28 // should be bound to the CompletionCallback that is passed to the disk_cache
  29 // API.  We do this by binding an instance of this struct to an unused
  30 // parameter for OnIOComplete() using base::Owned().
  31 //
  32 // This is a hack. A better fix is to make it so that the disk_cache APIs
  33 // take a Callback to a mutator for setting the output value rather than
  34 // writing into a raw handle. Then the caller can just pass in a Callback
  35 // bound to WeakPtr for itself. This callback would correctly "no-op" itself
  36 // when the DiskCacheBasedQuicServerInfo object is deleted.
  37 //
  38 // TODO(ajwong): Change disk_cache's API to return results via Callback.
  39 struct DiskCacheBasedQuicServerInfo::CacheOperationDataShim {
  40   CacheOperationDataShim() : backend(NULL), entry(NULL) {}
  41
  42   disk_cache::Backend* backend;
  43   disk_cache::Entry* entry;
  44 };
  45
  46 DiskCacheBasedQuicServerInfo::DiskCacheBasedQuicServerInfo(
  47     const QuicServerId& server_id,
  48     HttpCache* http_cache)
  49     : QuicServerInfo(server_id),
  50       weak_factory_(this),
  51       data_shim_(new CacheOperationDataShim()),
  52       io_callback_(
  53           base::Bind(&DiskCacheBasedQuicServerInfo::OnIOComplete,
  54                      weak_factory_.GetWeakPtr(),
  55                      base::Owned(data_shim_))),  // Ownership assigned.
  56       state_(GET_BACKEND),
  57       ready_(false),
  58       found_entry_(false),
  59       server_id_(server_id),
  60       http_cache_(http_cache),
  61       backend_(NULL),
  62       entry_(NULL) {
  63 }
  64
  65 void DiskCacheBasedQuicServerInfo::Start() {
  66   DCHECK(CalledOnValidThread());
  67   DCHECK_EQ(GET_BACKEND, state_);
  68   DoLoop(OK);
  69 }
  70
  71 int DiskCacheBasedQuicServerInfo::WaitForDataReady(
  72     const CompletionCallback& callback) {
  73   DCHECK(CalledOnValidThread());
  74   DCHECK_NE(GET_BACKEND, state_);
  75
  76   if (ready_)
  77     return OK;
  78
  79   if (!callback.is_null()) {
  80     // Prevent a new callback for WaitForDataReady overwriting an existing
  81     // pending callback (|user_callback_|).
  82     if (!user_callback_.is_null())
  83       return ERR_INVALID_ARGUMENT;
  84     user_callback_ = callback;
  85   }
  86
  87   return ERR_IO_PENDING;
  88 }
  89
  90 bool DiskCacheBasedQuicServerInfo::IsDataReady() {
  91   return ready_;
  92 }
  93
  94 bool DiskCacheBasedQuicServerInfo::IsReadyToPersist() {
  95   // The data can be persisted if it has been loaded from the disk cache
  96   // and there are no pending writes.
  97   return ready_ && new_data_.empty();
  98 }
  99
 100 void DiskCacheBasedQuicServerInfo::Persist() {
 101   DCHECK(CalledOnValidThread());
 102   DCHECK_NE(GET_BACKEND, state_);
 103
 104   DCHECK(new_data_.empty());
 105   CHECK(ready_);
 106   DCHECK(user_callback_.is_null());
 107   new_data_ = Serialize();
 108
 109   if (!backend_)
 110     return;
 111
 112   state_ = CREATE_OR_OPEN;
 113   DoLoop(OK);
 114 }
 115
 116 DiskCacheBasedQuicServerInfo::~DiskCacheBasedQuicServerInfo() {
 117   DCHECK(user_callback_.is_null());
 118   if (entry_)
 119     entry_->Close();
 120 }
 121
 122 std::string DiskCacheBasedQuicServerInfo::key() const {
 123   return "quicserverinfo:" + server_id_.ToString();
 124 }
 125
 126 void DiskCacheBasedQuicServerInfo::OnIOComplete(CacheOperationDataShim* unused,
 127                                                 int rv) {
 128   DCHECK_NE(NONE, state_);
 129   rv = DoLoop(rv);
 130   if (rv != ERR_IO_PENDING && !user_callback_.is_null()) {
 131     CompletionCallback callback = user_callback_;
 132     user_callback_.Reset();
 133     callback.Run(rv);
 134   }
 135 }
 136
 137 int DiskCacheBasedQuicServerInfo::DoLoop(int rv) {
 138   do {
 139     switch (state_) {
 140       case GET_BACKEND:
 141         rv = DoGetBackend();
 142         break;
 143       case GET_BACKEND_COMPLETE:
 144         rv = DoGetBackendComplete(rv);
 145         break;
 146       case OPEN:
 147         rv = DoOpen();
 148         break;
 149       case OPEN_COMPLETE:
 150         rv = DoOpenComplete(rv);
 151         break;
 152       case READ:
 153         rv = DoRead();
 154         break;
 155       case READ_COMPLETE:
 156         rv = DoReadComplete(rv);
 157         break;
 158       case WAIT_FOR_DATA_READY_DONE:
 159         rv = DoWaitForDataReadyDone();
 160         break;
 161       case CREATE_OR_OPEN:
 162         rv = DoCreateOrOpen();
 163         break;
 164       case CREATE_OR_OPEN_COMPLETE:
 165         rv = DoCreateOrOpenComplete(rv);
 166         break;
 167       case WRITE:
 168         rv = DoWrite();
 169         break;
 170       case WRITE_COMPLETE:
 171         rv = DoWriteComplete(rv);
 172         break;
 173       case SET_DONE:
 174         rv = DoSetDone();
 175         break;
 176       default:
 177         rv = OK;
 178         NOTREACHED();
 179     }
 180   } while (rv != ERR_IO_PENDING && state_ != NONE);
 181
 182   return rv;
 183 }
 184
 185 int DiskCacheBasedQuicServerInfo::DoGetBackendComplete(int rv) {
 186   if (rv == OK) {
 187     backend_ = data_shim_->backend;
 188     state_ = OPEN;
 189   } else {
 190     state_ = WAIT_FOR_DATA_READY_DONE;
 191   }
 192   return OK;
 193 }
 194
 195 int DiskCacheBasedQuicServerInfo::DoOpenComplete(int rv) {
 196   if (rv == OK) {
 197     entry_ = data_shim_->entry;
 198     state_ = READ;
 199     found_entry_ = true;
 200   } else {
 201     state_ = WAIT_FOR_DATA_READY_DONE;
 202   }
 203
 204   return OK;
 205 }
 206
 207 int DiskCacheBasedQuicServerInfo::DoReadComplete(int rv) {
 208   if (rv > 0)
 209     data_.assign(read_buffer_->data(), rv);
 210
 211   state_ = WAIT_FOR_DATA_READY_DONE;
 212   return OK;
 213 }
 214
 215 int DiskCacheBasedQuicServerInfo::DoWriteComplete(int rv) {
 216   state_ = SET_DONE;
 217   return OK;
 218 }
 219
 220 int DiskCacheBasedQuicServerInfo::DoCreateOrOpenComplete(int rv) {
 221   if (rv != OK) {
 222     state_ = SET_DONE;
 223   } else {
 224     entry_ = data_shim_->entry;
 225     state_ = WRITE;
 226   }
 227   return OK;
 228 }
 229
 230 int DiskCacheBasedQuicServerInfo::DoGetBackend() {
 231   state_ = GET_BACKEND_COMPLETE;
 232   return http_cache_->GetBackend(&data_shim_->backend, io_callback_);
 233 }
 234
 235 int DiskCacheBasedQuicServerInfo::DoOpen() {
 236   state_ = OPEN_COMPLETE;
 237   return backend_->OpenEntry(key(), &data_shim_->entry, io_callback_);
 238 }
 239
 240 int DiskCacheBasedQuicServerInfo::DoRead() {
 241   const int32 size = entry_->GetDataSize(0 /* index */);
 242   if (!size) {
 243     state_ = WAIT_FOR_DATA_READY_DONE;
 244     return OK;
 245   }
 246
 247   read_buffer_ = new IOBuffer(size);
 248   state_ = READ_COMPLETE;
 249   return entry_->ReadData(
 250       0 /* index */, 0 /* offset */, read_buffer_, size, io_callback_);
 251 }
 252
 253 int DiskCacheBasedQuicServerInfo::DoWrite() {
 254   write_buffer_ = new IOBuffer(new_data_.size());
 255   memcpy(write_buffer_->data(), new_data_.data(), new_data_.size());
 256   state_ = WRITE_COMPLETE;
 257
 258   return entry_->WriteData(
 259       0 /* index */, 0 /* offset */, write_buffer_, new_data_.size(),
 260       io_callback_, true /* truncate */);
 261 }
 262
 263 int DiskCacheBasedQuicServerInfo::DoCreateOrOpen() {
 264   DCHECK(entry_ == NULL);
 265   state_ = CREATE_OR_OPEN_COMPLETE;
 266   if (found_entry_) {
 267     return backend_->OpenEntry(key(), &data_shim_->entry, io_callback_);
 268   }
 269
 270   return backend_->CreateEntry(key(), &data_shim_->entry, io_callback_);
 271 }
 272
 273 int DiskCacheBasedQuicServerInfo::DoWaitForDataReadyDone() {
 274   DCHECK(!ready_);
 275   state_ = NONE;
 276   ready_ = true;
 277   // We close the entry because, if we shutdown before ::Persist is called,
 278   // then we might leak a cache reference, which causes a DCHECK on shutdown.
 279   if (entry_)
 280     entry_->Close();
 281   entry_ = NULL;
 282   Parse(data_);
 283   return OK;
 284 }
 285
 286 int DiskCacheBasedQuicServerInfo::DoSetDone() {
 287   if (entry_)
 288     entry_->Close();
 289   entry_ = NULL;
 290   new_data_.clear();
 291   state_ = NONE;
 292   return OK;
 293 }
 294
 295 }  // namespace net