[Blob] Better error reporting and histograms.

content/browser/blob_storage/blob_dispatcher_host.cc

 // Copyright 2016 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 "content/browser/blob_storage/blob_dispatcher_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "content/browser/bad_message.h"
@@ skipping 45 matching lines @@
   return handled;
 }
 
 void BlobDispatcherHost::OnRegisterBlobUUID(
     const std::string& uuid,
     const std::string& content_type,
     const std::string& content_disposition,
     const std::set<std::string>& referenced_blob_uuids) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BlobStorageContext* context = this->context();
-  if (uuid.empty() || context->registry().HasEntry(uuid)) {
+  if (uuid.empty() || context->registry().HasEntry(uuid) ||
+      async_builder_.IsBeingBuilt(uuid)) {
     bad_message::ReceivedBadMessage(this, bad_message::BDH_UUID_REGISTERED);
     return;
   }
   blobs_inuse_map_[uuid] = 1;
   BlobTransportResult result = async_builder_.RegisterBlobUUID(
       uuid, content_type, content_disposition, referenced_blob_uuids, context);
   switch (result) {
     case BlobTransportResult::BAD_IPC:
       blobs_inuse_map_.erase(uuid);
-      bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
+      bad_message::ReceivedBadMessage(this,
+                                      bad_message::BDH_CONSTRUCTION_FAILED);
       break;
-      ;
     case BlobTransportResult::CANCEL_REFERENCED_BLOB_BROKEN:
       // The async builder builds the blob as broken, and we just need to send
       // the cancel message back to the renderer.
       Send(new BlobStorageMsg_CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN));
       break;
     case BlobTransportResult::DONE:
       break;
     case BlobTransportResult::CANCEL_MEMORY_FULL:
     case BlobTransportResult::CANCEL_FILE_ERROR:
@@ skipping 112 matching lines @@
   }
   VLOG(1) << "Blob construction of " << uuid << " cancelled by renderer. "
           << " Reason: " << static_cast<int>(code) << ".";
   async_builder_.CancelBuildingBlob(uuid, code, context);
 }
 
 void BlobDispatcherHost::OnIncrementBlobRefCount(const std::string& uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BlobStorageContext* context = this->context();
   if (uuid.empty() || !context->registry().HasEntry(uuid)) {
-    bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
+    bad_message::ReceivedBadMessage(
+        this, bad_message::BDH_INVALID_REFCOUNT_OPERATION);
     return;
   }
   context->IncrementBlobRefCount(uuid);
   blobs_inuse_map_[uuid] += 1;
 }
 
 void BlobDispatcherHost::OnDecrementBlobRefCount(const std::string& uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (uuid.empty() || !IsInUseInHost(uuid)) {
-    bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
+    bad_message::ReceivedBadMessage(
+        this, bad_message::BDH_INVALID_REFCOUNT_OPERATION);
     return;
   }
   BlobStorageContext* context = this->context();
   context->DecrementBlobRefCount(uuid);
   blobs_inuse_map_[uuid] -= 1;
   if (blobs_inuse_map_[uuid] == 0) {
     blobs_inuse_map_.erase(uuid);
     // If the blob has been deleted in the context and we're still building it,
     // this means we have no references waiting to read it. Clear the building
     // state and send a cancel message to the renderer.
     if (async_builder_.IsBeingBuilt(uuid) &&
         !context->registry().HasEntry(uuid)) {
       async_builder_.CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING,
           context);
       Send(new BlobStorageMsg_CancelBuildingBlob(
           uuid, IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING));
     }
   }
 }
 
 void BlobDispatcherHost::OnRegisterPublicBlobURL(const GURL& public_url,
                                                  const std::string& uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BlobStorageContext* context = this->context();
   if (uuid.empty() || !IsInUseInHost(uuid) ||
       context->registry().IsURLMapped(public_url)) {
-    bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
+    bad_message::ReceivedBadMessage(this,
+                                    bad_message::BDH_INVALID_URL_OPERATION);
     return;
   }
   context->RegisterPublicBlobURL(public_url, uuid);
   public_blob_urls_.insert(public_url);
 }
 
 void BlobDispatcherHost::OnRevokePublicBlobURL(const GURL& public_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!IsUrlRegisteredInHost(public_url)) {
-    bad_message::ReceivedBadMessage(this, bad_message::BDH_INVALID_OPERATION);
+    bad_message::ReceivedBadMessage(this,
+                                    bad_message::BDH_INVALID_URL_OPERATION);
     return;
   }
   context()->RevokePublicBlobURL(public_url);
   public_blob_urls_.erase(public_url);
 }
 
 storage::BlobStorageContext* BlobDispatcherHost::context() {
   return blob_storage_context_->context();
 }
 
@@ skipping 56 matching lines @@
     context->RevokePublicBlobURL(url);
   }
   for (const auto& uuid_refnum_pair : blobs_inuse_map_) {
     for (int i = 0; i < uuid_refnum_pair.second; ++i)
       context->DecrementBlobRefCount(uuid_refnum_pair.first);
   }
   async_builder_.CancelAll(context);
 }
 
 }  // namespace content