content/browser/appcache/appcache_response.cc

   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 "content/browser/appcache/appcache_response.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/message_loop/message_loop.h"
  12 #include "base/pickle.h"
  13 #include "base/strings/string_util.h"
  14 #include "content/browser/appcache/appcache_storage.h"
  15 #include "net/base/completion_callback.h"
  16 #include "net/base/io_buffer.h"
  17 #include "net/base/net_errors.h"
  18
  19 namespace content {
  20
  21 namespace {
  22
  23 // Disk cache entry data indices.
  24 enum {
  25   kResponseInfoIndex,
  26   kResponseContentIndex
  27 };
  28
  29 // An IOBuffer that wraps a pickle's data. Ownership of the
  30 // pickle is transfered to the WrappedPickleIOBuffer object.
  31 class WrappedPickleIOBuffer : public net::WrappedIOBuffer {
  32  public:
  33   explicit WrappedPickleIOBuffer(const Pickle* pickle) :
  34       net::WrappedIOBuffer(reinterpret_cast<const char*>(pickle->data())),
  35       pickle_(pickle) {
  36     DCHECK(pickle->data());
  37   }
  38
  39  private:
  40   virtual ~WrappedPickleIOBuffer() {}
  41
  42   scoped_ptr<const Pickle> pickle_;
  43 };
  44
  45 }  // anon namespace
  46
  47
  48 // AppCacheResponseInfo ----------------------------------------------
  49
  50 AppCacheResponseInfo::AppCacheResponseInfo(
  51     AppCacheStorage* storage, const GURL& manifest_url,
  52     int64 response_id,  net::HttpResponseInfo* http_info,
  53     int64 response_data_size)
  54     : manifest_url_(manifest_url), response_id_(response_id),
  55       http_response_info_(http_info), response_data_size_(response_data_size),
  56       storage_(storage) {
  57   DCHECK(http_info);
  58   DCHECK(response_id != kAppCacheNoResponseId);
  59   storage_->working_set()->AddResponseInfo(this);
  60 }
  61
  62 AppCacheResponseInfo::~AppCacheResponseInfo() {
  63   storage_->working_set()->RemoveResponseInfo(this);
  64 }
  65
  66 // HttpResponseInfoIOBuffer ------------------------------------------
  67
  68 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer()
  69     : response_data_size(kUnkownResponseDataSize) {}
  70
  71 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer(net::HttpResponseInfo* info)
  72     : http_info(info), response_data_size(kUnkownResponseDataSize) {}
  73
  74 HttpResponseInfoIOBuffer::~HttpResponseInfoIOBuffer() {}
  75
  76 // AppCacheResponseIO ----------------------------------------------
  77
  78 AppCacheResponseIO::AppCacheResponseIO(
  79     int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
  80     : response_id_(response_id),
  81       group_id_(group_id),
  82       disk_cache_(disk_cache),
  83       entry_(NULL),
  84       buffer_len_(0),
  85       weak_factory_(this) {
  86 }
  87
  88 AppCacheResponseIO::~AppCacheResponseIO() {
  89   if (entry_)
  90     entry_->Close();
  91 }
  92
  93 void AppCacheResponseIO::ScheduleIOCompletionCallback(int result) {
  94   base::MessageLoop::current()->PostTask(
  95       FROM_HERE, base::Bind(&AppCacheResponseIO::OnIOComplete,
  96                             weak_factory_.GetWeakPtr(), result));
  97 }
  98
  99 void AppCacheResponseIO::InvokeUserCompletionCallback(int result) {
 100   // Clear the user callback and buffers prior to invoking the callback
 101   // so the caller can schedule additional operations in the callback.
 102   buffer_ = NULL;
 103   info_buffer_ = NULL;
 104   net::CompletionCallback cb = callback_;
 105   callback_.Reset();
 106   cb.Run(result);
 107 }
 108
 109 void AppCacheResponseIO::ReadRaw(int index, int offset,
 110                                  net::IOBuffer* buf, int buf_len) {
 111   DCHECK(entry_);
 112   int rv = entry_->Read(
 113       index, offset, buf, buf_len,
 114       base::Bind(&AppCacheResponseIO::OnRawIOComplete,
 115                  weak_factory_.GetWeakPtr()));
 116   if (rv != net::ERR_IO_PENDING)
 117     ScheduleIOCompletionCallback(rv);
 118 }
 119
 120 void AppCacheResponseIO::WriteRaw(int index, int offset,
 121                                  net::IOBuffer* buf, int buf_len) {
 122   DCHECK(entry_);
 123   int rv = entry_->Write(
 124       index, offset, buf, buf_len,
 125       base::Bind(&AppCacheResponseIO::OnRawIOComplete,
 126                  weak_factory_.GetWeakPtr()));
 127   if (rv != net::ERR_IO_PENDING)
 128     ScheduleIOCompletionCallback(rv);
 129 }
 130
 131 void AppCacheResponseIO::OnRawIOComplete(int result) {
 132   DCHECK_NE(net::ERR_IO_PENDING, result);
 133   OnIOComplete(result);
 134 }
 135
 136
 137 // AppCacheResponseReader ----------------------------------------------
 138
 139 AppCacheResponseReader::AppCacheResponseReader(
 140     int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
 141     : AppCacheResponseIO(response_id, group_id, disk_cache),
 142       range_offset_(0),
 143       range_length_(kint32max),
 144       read_position_(0),
 145       weak_factory_(this) {
 146 }
 147
 148 AppCacheResponseReader::~AppCacheResponseReader() {
 149 }
 150
 151 void AppCacheResponseReader::ReadInfo(HttpResponseInfoIOBuffer* info_buf,
 152                                       const net::CompletionCallback& callback) {
 153   DCHECK(!callback.is_null());
 154   DCHECK(!IsReadPending());
 155   DCHECK(info_buf);
 156   DCHECK(!info_buf->http_info.get());
 157   DCHECK(!buffer_.get());
 158   DCHECK(!info_buffer_.get());
 159
 160   info_buffer_ = info_buf;
 161   callback_ = callback;  // cleared on completion
 162   OpenEntryIfNeededAndContinue();
 163 }
 164
 165 void AppCacheResponseReader::ContinueReadInfo() {
 166   if (!entry_)  {
 167     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
 168     return;
 169   }
 170
 171   int size = entry_->GetSize(kResponseInfoIndex);
 172   if (size <= 0) {
 173     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
 174     return;
 175   }
 176
 177   buffer_ = new net::IOBuffer(size);
 178   ReadRaw(kResponseInfoIndex, 0, buffer_.get(), size);
 179 }
 180
 181 void AppCacheResponseReader::ReadData(net::IOBuffer* buf, int buf_len,
 182                                       const net::CompletionCallback& callback) {
 183   DCHECK(!callback.is_null());
 184   DCHECK(!IsReadPending());
 185   DCHECK(buf);
 186   DCHECK(buf_len >= 0);
 187   DCHECK(!buffer_.get());
 188   DCHECK(!info_buffer_.get());
 189
 190   buffer_ = buf;
 191   buffer_len_ = buf_len;
 192   callback_ = callback;  // cleared on completion
 193   OpenEntryIfNeededAndContinue();
 194 }
 195
 196 void AppCacheResponseReader::ContinueReadData() {
 197   if (!entry_)  {
 198     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
 199     return;
 200   }
 201
 202   if (read_position_ + buffer_len_ > range_length_) {
 203     // TODO(michaeln): What about integer overflows?
 204     DCHECK(range_length_ >= read_position_);
 205     buffer_len_ = range_length_ - read_position_;
 206   }
 207   ReadRaw(kResponseContentIndex,
 208           range_offset_ + read_position_,
 209           buffer_.get(),
 210           buffer_len_);
 211 }
 212
 213 void AppCacheResponseReader::SetReadRange(int offset, int length) {
 214   DCHECK(!IsReadPending() && !read_position_);
 215   range_offset_ = offset;
 216   range_length_ = length;
 217 }
 218
 219 void AppCacheResponseReader::OnIOComplete(int result) {
 220   if (result >= 0) {
 221     if (info_buffer_.get()) {
 222       // Deserialize the http info structure, ensuring we got headers.
 223       Pickle pickle(buffer_->data(), result);
 224       scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
 225       bool response_truncated = false;
 226       if (!info->InitFromPickle(pickle, &response_truncated) ||
 227           !info->headers.get()) {
 228         InvokeUserCompletionCallback(net::ERR_FAILED);
 229         return;
 230       }
 231       DCHECK(!response_truncated);
 232       info_buffer_->http_info.reset(info.release());
 233
 234       // Also return the size of the response body
 235       DCHECK(entry_);
 236       info_buffer_->response_data_size =
 237           entry_->GetSize(kResponseContentIndex);
 238     } else {
 239       read_position_ += result;
 240     }
 241   }
 242   InvokeUserCompletionCallback(result);
 243 }
 244
 245 void AppCacheResponseReader::OpenEntryIfNeededAndContinue() {
 246   int rv;
 247   AppCacheDiskCacheInterface::Entry** entry_ptr = NULL;
 248   if (entry_) {
 249     rv = net::OK;
 250   } else if (!disk_cache_) {
 251     rv = net::ERR_FAILED;
 252   } else {
 253     entry_ptr = new AppCacheDiskCacheInterface::Entry*;
 254     open_callback_ =
 255         base::Bind(&AppCacheResponseReader::OnOpenEntryComplete,
 256                    weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
 257     rv = disk_cache_->OpenEntry(response_id_, entry_ptr, open_callback_);
 258   }
 259
 260   if (rv != net::ERR_IO_PENDING)
 261     OnOpenEntryComplete(entry_ptr, rv);
 262 }
 263
 264 void AppCacheResponseReader::OnOpenEntryComplete(
 265     AppCacheDiskCacheInterface::Entry** entry, int rv) {
 266   DCHECK(info_buffer_.get() || buffer_.get());
 267
 268   if (!open_callback_.is_null()) {
 269     if (rv == net::OK) {
 270       DCHECK(entry);
 271       entry_ = *entry;
 272     }
 273     open_callback_.Reset();
 274   }
 275
 276   if (info_buffer_.get())
 277     ContinueReadInfo();
 278   else
 279     ContinueReadData();
 280 }
 281
 282 // AppCacheResponseWriter ----------------------------------------------
 283
 284 AppCacheResponseWriter::AppCacheResponseWriter(
 285     int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
 286     : AppCacheResponseIO(response_id, group_id, disk_cache),
 287       info_size_(0),
 288       write_position_(0),
 289       write_amount_(0),
 290       creation_phase_(INITIAL_ATTEMPT),
 291       weak_factory_(this) {
 292 }
 293
 294 AppCacheResponseWriter::~AppCacheResponseWriter() {
 295 }
 296
 297 void AppCacheResponseWriter::WriteInfo(
 298     HttpResponseInfoIOBuffer* info_buf,
 299     const net::CompletionCallback& callback) {
 300   DCHECK(!callback.is_null());
 301   DCHECK(!IsWritePending());
 302   DCHECK(info_buf);
 303   DCHECK(info_buf->http_info.get());
 304   DCHECK(!buffer_.get());
 305   DCHECK(!info_buffer_.get());
 306   DCHECK(info_buf->http_info->headers.get());
 307
 308   info_buffer_ = info_buf;
 309   callback_ = callback;  // cleared on completion
 310   CreateEntryIfNeededAndContinue();
 311 }
 312
 313 void AppCacheResponseWriter::ContinueWriteInfo() {
 314   if (!entry_) {
 315     ScheduleIOCompletionCallback(net::ERR_FAILED);
 316     return;
 317   }
 318
 319   const bool kSkipTransientHeaders = true;
 320   const bool kTruncated = false;
 321   Pickle* pickle = new Pickle;
 322   info_buffer_->http_info->Persist(pickle, kSkipTransientHeaders, kTruncated);
 323   write_amount_ = static_cast<int>(pickle->size());
 324   buffer_ = new WrappedPickleIOBuffer(pickle);  // takes ownership of pickle
 325   WriteRaw(kResponseInfoIndex, 0, buffer_.get(), write_amount_);
 326 }
 327
 328 void AppCacheResponseWriter::WriteData(
 329     net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
 330   DCHECK(!callback.is_null());
 331   DCHECK(!IsWritePending());
 332   DCHECK(buf);
 333   DCHECK(buf_len >= 0);
 334   DCHECK(!buffer_.get());
 335   DCHECK(!info_buffer_.get());
 336
 337   buffer_ = buf;
 338   write_amount_ = buf_len;
 339   callback_ = callback;  // cleared on completion
 340   CreateEntryIfNeededAndContinue();
 341 }
 342
 343 void AppCacheResponseWriter::ContinueWriteData() {
 344   if (!entry_) {
 345     ScheduleIOCompletionCallback(net::ERR_FAILED);
 346     return;
 347   }
 348   WriteRaw(
 349       kResponseContentIndex, write_position_, buffer_.get(), write_amount_);
 350 }
 351
 352 void AppCacheResponseWriter::OnIOComplete(int result) {
 353   if (result >= 0) {
 354     DCHECK(write_amount_ == result);
 355     if (!info_buffer_.get())
 356       write_position_ += result;
 357     else
 358       info_size_ = result;
 359   }
 360   InvokeUserCompletionCallback(result);
 361 }
 362
 363 void AppCacheResponseWriter::CreateEntryIfNeededAndContinue() {
 364   int rv;
 365   AppCacheDiskCacheInterface::Entry** entry_ptr = NULL;
 366   if (entry_) {
 367     creation_phase_ = NO_ATTEMPT;
 368     rv = net::OK;
 369   } else if (!disk_cache_) {
 370     creation_phase_ = NO_ATTEMPT;
 371     rv = net::ERR_FAILED;
 372   } else {
 373     creation_phase_ = INITIAL_ATTEMPT;
 374     entry_ptr = new AppCacheDiskCacheInterface::Entry*;
 375     create_callback_ =
 376         base::Bind(&AppCacheResponseWriter::OnCreateEntryComplete,
 377                    weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
 378     rv = disk_cache_->CreateEntry(response_id_, entry_ptr, create_callback_);
 379   }
 380   if (rv != net::ERR_IO_PENDING)
 381     OnCreateEntryComplete(entry_ptr, rv);
 382 }
 383
 384 void AppCacheResponseWriter::OnCreateEntryComplete(
 385     AppCacheDiskCacheInterface::Entry** entry, int rv) {
 386   DCHECK(info_buffer_.get() || buffer_.get());
 387
 388   if (creation_phase_ == INITIAL_ATTEMPT) {
 389     if (rv != net::OK) {
 390       // We may try to overwrite existing entries.
 391       creation_phase_ = DOOM_EXISTING;
 392       rv = disk_cache_->DoomEntry(response_id_, create_callback_);
 393       if (rv != net::ERR_IO_PENDING)
 394         OnCreateEntryComplete(NULL, rv);
 395       return;
 396     }
 397   } else if (creation_phase_ == DOOM_EXISTING) {
 398     creation_phase_ = SECOND_ATTEMPT;
 399     AppCacheDiskCacheInterface::Entry** entry_ptr =
 400         new AppCacheDiskCacheInterface::Entry*;
 401     create_callback_ =
 402         base::Bind(&AppCacheResponseWriter::OnCreateEntryComplete,
 403                    weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
 404     rv = disk_cache_->CreateEntry(response_id_, entry_ptr, create_callback_);
 405     if (rv != net::ERR_IO_PENDING)
 406       OnCreateEntryComplete(entry_ptr, rv);
 407     return;
 408   }
 409
 410   if (!create_callback_.is_null()) {
 411     if (rv == net::OK)
 412       entry_ = *entry;
 413
 414     create_callback_.Reset();
 415   }
 416
 417   if (info_buffer_.get())
 418     ContinueWriteInfo();
 419   else
 420     ContinueWriteData();
 421 }
 422
 423 }  // namespace content