Create blobs from Disk Cache entries.

storage/browser/blob/blob_url_request_job.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "storage/browser/blob/blob_url_request_job.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util_proxy.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "net/disk_cache/disk_cache.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_status.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
 #include "storage/browser/fileapi/file_system_context.h"
@@ skipping 314 matching lines @@
   // If nothing to read for current item, advance to next item.
   if (bytes_to_read == 0) {
     AdvanceItem();
     return true;
   }
 
   // Do the reading.
   const BlobDataItem& item = *items.at(current_item_index_);
   if (item.type() == DataElement::TYPE_BYTES)
     return ReadBytesItem(item, bytes_to_read);
+  if (item.type() == DataElement::TYPE_DISK_CACHE_ENTRY)
+    return ReadDiskCacheEntryItem(item, bytes_to_read);
   if (!IsFileType(item.type())) {
     NOTREACHED();
     return false;
   }
   storage::FileStreamReader* const reader =
       GetFileStreamReader(current_item_index_);
   if (!reader) {
     NotifyFailure(net::ERR_FAILED);
     return false;
   }
@@ skipping 44 matching lines @@
 bool BlobURLRequestJob::ReadFileItem(FileStreamReader* reader,
                                      int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
   DCHECK(reader);
   int chunk_number = current_file_chunk_number_++;
   TRACE_EVENT_ASYNC_BEGIN1("Blob", "BlobRequest::ReadFileItem", this, "uuid",
                            blob_data_->uuid());
   const int result =
       reader->Read(read_buf_.get(), bytes_to_read,
                    base::Bind(&BlobURLRequestJob::DidReadFile,
-                              base::Unretained(this), chunk_number));
+                              weak_factory_.GetWeakPtr(), chunk_number));

[gavinp, 2015/06/17 15:14:21]

This was a mistake, but I say we leave it in: it certainly looks a lot safer and
it's quite low cost on a class that already has weakptrs. It's a belt _and_
suspenders.

[michaeln, 2015/06/17 20:49:35]

yes please, use a weakptr here too

   if (result >= 0) {
     // Data is immediately available.
     if (GetStatus().is_io_pending())
       DidReadFile(chunk_number, result);
     else
       AdvanceBytesRead(result);
     return true;
   }
   if (result == net::ERR_IO_PENDING)
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
@@ skipping 27 matching lines @@
 }
 
 void BlobURLRequestJob::DeleteCurrentFileReader() {
   IndexToReaderMap::iterator found = index_to_reader_.find(current_item_index_);
   if (found != index_to_reader_.end() && found->second) {
     delete found->second;
     index_to_reader_.erase(found);
   }
 }
 
+bool BlobURLRequestJob::ReadDiskCacheEntryItem(const BlobDataItem& item,
+                                               int bytes_to_read) {
+  DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
+
+  const int result = item.disk_cache_entry()->ReadData(

[gavinp, 2015/06/17 15:14:21]

This const stayed in for consistency with line 423, above.

+      item.disk_cache_stream_index(), current_item_offset_, read_buf_.get(),
+      bytes_to_read, base::Bind(&BlobURLRequestJob::DidReadDiskCacheEntry,
+                                base::Unretained(this)));

[gavinp, 2015/06/17 15:14:21]

OMG, I fixed the wrong base::Unretained()!

[michaeln, 2015/06/17 20:49:35]

yikes, thnx for catching this!

+  if (result >= 0) {
+    // Data is immediately available.
+    if (GetStatus().is_io_pending())
+      DidReadDiskCacheEntry(result);
+    else
+      AdvanceBytesRead(result);
+    return true;
+  }
+  if (result == net::ERR_IO_PENDING)
+    SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
+  else
+    NotifyFailure(result);
+  return false;
+}
+
+void BlobURLRequestJob::DidReadDiskCacheEntry(int result) {
+  if (result <= 0) {
+    NotifyFailure(net::ERR_FAILED);
+    return;
+  }
+  SetStatus(net::URLRequestStatus());
+
+  AdvanceBytesRead(result);
+
+  if (!read_buf_->BytesRemaining()) {
+    int bytes_read = BytesReadCompleted();
+    NotifyReadComplete(bytes_read);
+    return;
+  }
+
+  int bytes_read = 0;
+  if (ReadLoop(&bytes_read))
+    NotifyReadComplete(bytes_read);
+}
+
 int BlobURLRequestJob::BytesReadCompleted() {
   int bytes_read = read_buf_->BytesConsumed();
   read_buf_ = NULL;
   return bytes_read;
 }
 
 int BlobURLRequestJob::ComputeBytesToRead() const {
   int64 current_item_length = item_length_list_[current_item_index_];
 
   int64 item_remaining = current_item_length - current_item_offset_;
@@ skipping 160 matching lines @@
 
     default:
       break;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace storage