[BlobAsync] Asynchronous Blob Construction Final Patch

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 "base/bind.h"
+#include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/blob/blob_reader.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_url.h"
 #include "url/gurl.h"
 
 namespace storage {
+using BlobState = BlobStorageRegistry::BlobState;
 
 namespace {
 
 class FileStreamReaderProviderImpl
     : public BlobReader::FileStreamReaderProvider {
  public:
-  FileStreamReaderProviderImpl(FileSystemContext* file_system_context)
+  explicit FileStreamReaderProviderImpl(FileSystemContext* file_system_context)
       : file_system_context_(file_system_context) {}
   ~FileStreamReaderProviderImpl() override {}
 
   scoped_ptr<FileStreamReader> CreateForLocalFile(
       base::TaskRunner* task_runner,
       const base::FilePath& file_path,
       int64_t initial_offset,
       const base::Time& expected_modification_time) override {
     return make_scoped_ptr(FileStreamReader::CreateForLocalFile(
         task_runner, file_path, initial_offset, expected_modification_time));
@@ skipping 21 matching lines @@
     const std::string& content_type,
     const std::string& content_disposition,
     BlobStorageContext* context)
     : uuid_(uuid),
       content_type_(content_type),
       content_disposition_(content_disposition),
       context_(context->AsWeakPtr()) {
   context_->IncrementBlobRefCount(uuid);
 }
 
+void BlobDataHandle::BlobDataHandleShared::RunOnConstructionComplete(
+    const base::Callback<void(bool)>& done) {
+  if (!context_.get()) {
+    done.Run(false);
+    return;
+  }
+  context_->RunOnConstructionComplete(uuid_, done);
+}
+
 scoped_ptr<BlobReader> BlobDataHandle::CreateReader(
     FileSystemContext* file_system_context,
     base::SequencedTaskRunner* file_task_runner) const {
   return scoped_ptr<BlobReader>(new BlobReader(
       this, scoped_ptr<BlobReader::FileStreamReaderProvider>(
                 new FileStreamReaderProviderImpl(file_system_context)),
       file_task_runner));
 }
 
 scoped_ptr<BlobDataSnapshot>
 BlobDataHandle::BlobDataHandleShared::CreateSnapshot() const {
+  if (!context_.get())
+    return nullptr;
   return context_->CreateSnapshot(uuid_);
 }
 
 BlobDataHandle::BlobDataHandleShared::~BlobDataHandleShared() {
   if (context_.get())
     context_->DecrementBlobRefCount(uuid_);
 }
 
 BlobDataHandle::BlobDataHandle(const std::string& uuid,
                                const std::string& content_type,
@@ skipping 16 matching lines @@
 
 BlobDataHandle::~BlobDataHandle() {
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     BlobDataHandleShared* raw = shared_.get();
     raw->AddRef();
     shared_ = nullptr;
     io_task_runner_->ReleaseSoon(FROM_HERE, raw);
   }
 }
 
+bool BlobDataHandle::IsBeingBuilt() const {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  if (!shared_->context_)
+    return false;
+  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_);
+}
+
+void BlobDataHandle::RunOnConstructionComplete(
+    const base::Callback<void(bool)>& done) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  shared_->RunOnConstructionComplete(done);
+}
+
 scoped_ptr<BlobDataSnapshot> BlobDataHandle::CreateSnapshot() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   return shared_->CreateSnapshot();
 }
 
 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_;
 }
 
 }  // namespace storage