[BlobAsync] Adding better error reporting and some new tests.

storage/browser/blob/blob_async_builder_host.h

 // Copyright 2015 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.
 
 #ifndef STORAGE_BROWSER_BLOB_BLOB_ASYNC_BUILDER_HOST_H_
 #define STORAGE_BROWSER_BLOB_BLOB_ASYNC_BUILDER_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 91 matching lines @@
   // the blob, or from the DispatcherHost (Renderer). If the blob isn't being
   // built then we do nothing.
   // Note: if the blob isn't in the context (renderer dereferenced it before we
   // finished constructing), then we don't bother touching the context.
   void CancelBuildingBlob(const std::string& uuid,
                           IPCBlobCreationCancelCode code,
                           BlobStorageContext* context);
 
   // This clears this object of pending construction. It also handles marking
   // blobs that haven't been fully constructed as broken in the context if there
-  // are any references being held by anyone.
+  // are any references being held by anyone. We know that they're being used
+  // by someone else if they still exist in the context.
   void CancelAll(BlobStorageContext* context);
 
   size_t blob_building_count() const { return async_blob_map_.size(); }
 
   bool IsBeingBuilt(const std::string& key) const {
     return async_blob_map_.find(key) != async_blob_map_.end();
   }
 
   // For testing use only.  Must be called before StartBuildingBlob.
   void SetMemoryConstantsForTesting(size_t max_ipc_memory_size,
@@ skipping 47 matching lines @@
 
   // This is the 'main loop' of our memory requests to the renderer.
   BlobTransportResult ContinueBlobMemoryRequests(const std::string& uuid,
                                                  BlobStorageContext* context);
 
   // This is our callback for when we want to finish the blob and we're waiting
   // for blobs we reference to be built. When the last callback occurs, we
   // complete the blob and erase our internal state.
   void ReferencedBlobFinished(const std::string& uuid,
                               base::WeakPtr<BlobStorageContext> context,
-                              bool construction_success);
+                              bool construction_success,
+                              IPCBlobCreationCancelCode reason);
 
   // This finishes creating the blob in the context, decrements blob references
   // that we were holding during construction, and erases our state.
   void FinishBuildingBlob(BlobBuildingState* state,
                           BlobStorageContext* context);
 
   AsyncBlobMap async_blob_map_;
 
   // Here for testing.
   size_t max_ipc_memory_size_ = kBlobStorageIPCThresholdBytes;
   size_t max_shared_memory_size_ = kBlobStorageMaxSharedMemoryBytes;
   uint64_t max_file_size_ = kBlobStorageMaxFileSizeBytes;
 
   base::WeakPtrFactory<BlobAsyncBuilderHost> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobAsyncBuilderHost);
 };
 
 }  // namespace storage
 #endif  // STORAGE_BROWSER_BLOB_BLOB_ASYNC_BUILDER_HOST_H_