[BlobAsync] Disk support for blob storage

storage/browser/blob/blob_data_handle.cc

 // Copyright (c) 2013 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_data_handle.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 49 matching lines @@
   scoped_refptr<FileSystemContext> file_system_context_;
   DISALLOW_COPY_AND_ASSIGN(FileStreamReaderProviderImpl);
 };
 
 }  // namespace
 
 BlobDataHandle::BlobDataHandleShared::BlobDataHandleShared(
     const std::string& uuid,
     const std::string& content_type,
     const std::string& content_disposition,
+    uint64_t size,
     BlobStorageContext* context)
     : uuid_(uuid),
       content_type_(content_type),
       content_disposition_(content_disposition),
+      size_(size),
       context_(context->AsWeakPtr()) {
   context_->IncrementBlobRefCount(uuid);
 }
 
 std::unique_ptr<BlobReader> BlobDataHandle::CreateReader(
     FileSystemContext* file_system_context,
     base::SequencedTaskRunner* file_task_runner) const {
   return std::unique_ptr<BlobReader>(new BlobReader(
       this, std::unique_ptr<BlobReader::FileStreamReaderProvider>(
                 new FileStreamReaderProviderImpl(file_system_context)),
       file_task_runner));
 }
 
 BlobDataHandle::BlobDataHandleShared::~BlobDataHandleShared() {
   if (context_.get())
     context_->DecrementBlobRefCount(uuid_);
 }
 
 BlobDataHandle::BlobDataHandle(const std::string& uuid,
                                const std::string& content_type,
                                const std::string& content_disposition,
+                               uint64_t size,
                                BlobStorageContext* context,
                                base::SequencedTaskRunner* io_task_runner)
     : io_task_runner_(io_task_runner),
       shared_(new BlobDataHandleShared(uuid,
                                        content_type,
                                        content_disposition,
+                                       size,
                                        context)) {
   DCHECK(io_task_runner_.get());
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 }
 
 BlobDataHandle::BlobDataHandle(const BlobDataHandle& other) {
   io_task_runner_ = other.io_task_runner_;
   shared_ = other.shared_;
 }
 
@@ skipping 13 matching lines @@
   return shared_->context_->IsBeingBuilt(shared_->uuid_);
 }
 
 bool BlobDataHandle::IsBroken() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (!shared_->context_)
     return true;
   return shared_->context_->IsBroken(shared_->uuid_);
 }
 
+IPCBlobCreationCancelCode BlobDataHandle::GetBrokenReason() const {
+  return shared_->context_->GetBrokenReason(shared_->uuid_);
+}
+
 void BlobDataHandle::RunOnConstructionComplete(
     const BlobConstructedCallback& done) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (!shared_->context_.get()) {
     done.Run(false, IPCBlobCreationCancelCode::UNKNOWN);
     return;
   }
   shared_->context_->RunOnConstructionComplete(shared_->uuid_, done);
 }
 
 std::unique_ptr<BlobDataSnapshot> BlobDataHandle::CreateSnapshot() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (!shared_->context_.get())
     return nullptr;
   return shared_->context_->CreateSnapshot(shared_->uuid_);
 }
 
 const std::string& BlobDataHandle::uuid() const {
   return shared_->uuid_;
 }
 
 const std::string& BlobDataHandle::content_type() const {
   return shared_->content_type_;
 }
 
 const std::string& BlobDataHandle::content_disposition() const {
   return shared_->content_disposition_;
 }
 
+uint64_t BlobDataHandle::size() const {
+  return shared_->size_;
+}
+
 }  // namespace storage