Logging and check fail crbug/612358

storage/browser/blob/blob_async_builder_host.cc

 // 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.
 
 #include "storage/browser/blob/blob_async_builder_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 273 matching lines @@
       return BlobTransportResult::CANCEL_MEMORY_FULL;
     }
     state->num_fulfilled_requests++;
   }
   return ContinueBlobMemoryRequests(uuid, context);
 }
 
 void BlobAsyncBuilderHost::CancelBuildingBlob(const std::string& uuid,
                                               IPCBlobCreationCancelCode code,
                                               BlobStorageContext* context) {
+  LOG(ERROR) << "Cancelling blob " << uuid;
   DCHECK(context);
   auto state_it = async_blob_map_.find(uuid);
   if (state_it == async_blob_map_.end()) {
     return;
   }
   // We can have the blob dereferenced by the renderer, but have it still being
   // 'built'. In this case, it's destructed in the context, but we still have
   // it in our map. Hence we make sure the context has the entry before
   // calling cancel.
   if (context->registry().HasEntry(uuid))
     context->CancelPendingBlob(uuid, code);
   async_blob_map_.erase(state_it);
 }
 
+
+
 void BlobAsyncBuilderHost::CancelAll(BlobStorageContext* context) {
   DCHECK(context);
   // If the blob still exists in the context (and is being built), then we know
   // that someone else is expecting our blob, and we need to cancel it to let
   // the dependency know it's gone.
   std::vector<std::unique_ptr<BlobDataHandle>> referenced_pending_blobs;
   for (const auto& uuid_state_pair : async_blob_map_) {
     if (context->IsBeingBuilt(uuid_state_pair.first)) {
+      auto* state = uuid_state_pair.second.get();
+      state->LogState();
       referenced_pending_blobs.emplace_back(
           context->GetBlobDataFromUUID(uuid_state_pair.first));
     }
   }
   // We clear the map before canceling them to prevent any strange reentry into
   // our class (see ReferencedBlobFinished) if any blobs were waiting for others
   // to construct.
   async_blob_map_.clear();
   for (const std::unique_ptr<BlobDataHandle>& handle :
        referenced_pending_blobs) {
+    LOG(ERROR) << "cancelling blob " << handle->uuid()
+               << " which is being expected by someone";
     context->CancelPendingBlob(
         handle->uuid(), IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT);
   }
 }
 
 BlobTransportResult BlobAsyncBuilderHost::ContinueBlobMemoryRequests(
     const std::string& uuid,
     BlobStorageContext* context) {
   AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid);
   DCHECK(state_it != async_blob_map_.end());
@@ skipping 47 matching lines @@
           if (!state->shared_memory_block->CreateAnonymous(size)) {
             DVLOG(1) << "Unable to allocate shared memory for blob transfer.";
             return BlobTransportResult::CANCEL_MEMORY_FULL;
           }
         }
         shared_memory->push_back(state->shared_memory_block->handle());
         byte_requests->push_back(request.message);
         // Since we are only using one handle at a time, transform our handle
         // index correctly back to 0.
         byte_requests->back().handle_index = 0;
+        LOG(ERROR) << uuid << " sending shared memory request";
         break;
       case IPCBlobItemRequestStrategy::FILE:
       case IPCBlobItemRequestStrategy::UNKNOWN:
         NOTREACHED() << "Not implemented yet.";
         break;
     }
     if (stop_accumulating) {
       break;
     }
   }
@@ skipping 53 matching lines @@
     if (state->num_referenced_blobs_building > 0) {
       // We wait until referenced blobs are done.
       return;
     }
   }
   context->CompletePendingBlob(state->data_builder);
   async_blob_map_.erase(state->data_builder.uuid());
 }
 
 }  // namespace storage