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 92 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(
+      item.disk_cache_stream_index(), current_item_offset_, read_buf_.get(),
+      bytes_to_read, base::Bind(&BlobURLRequestJob::DidReadDiskCacheEntry,
+                                base::Unretained(this)));

[michaeln, 2015/06/12 23:43:06]

2 questions:

1) How is base::Unretained here safe? I don't think it is.

It's safe in ReadFileItem() because when this class is destructed the
FileStreamReader is deleted so that completion callback won't be called.

In this case, |item| is refcounted and outlives this job. And Entry's are
supposed to invoke the completion callback even after being closed.

WeakPtr?

2) Is it ok to have two ReadData calls pending against the same Entry instance.
Two different jobs could be running at the same time. Pretty sure its ok, but
just checking.

+  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