Logging and check fail crbug/612358

content/child/blob_storage/blob_transport_controller.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 "content/child/blob_storage/blob_transport_controller.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
+#include "base/threading/platform_thread.h"
 #include "base/stl_util.h"
 #include "content/child/blob_storage/blob_consolidation.h"
 #include "content/child/child_process.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "ipc/ipc_sender.h"
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
 #include "storage/common/blob_storage/blob_item_bytes_response.h"
 #include "storage/common/data_element.h"
 #include "third_party/WebKit/public/platform/Platform.h"
@@ skipping 35 matching lines @@
 }
 
 // static
 void BlobTransportController::InitiateBlobTransfer(
     const std::string& uuid,
     const std::string& content_type,
     std::unique_ptr<BlobConsolidation> consolidation,
     scoped_refptr<ThreadSafeSender> sender,
     base::SingleThreadTaskRunner* io_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner) {
+  BlobTransportController* controller = BlobTransportController::GetInstance();
+  if (consolidation->total_memory() > kBlobStorageIPCThresholdBytes) {
+    LOG(ERROR)
+        << uuid
+        << " is about to be saved and send messages to browser. Instance: "
+        << controller << ", " << base::PlatformThread::GetName();
+  }
   if (main_runner->BelongsToCurrentThread()) {
     IncChildProcessRefCount();
   } else {
     main_runner->PostTask(FROM_HERE, base::Bind(&IncChildProcessRefCount));
   }
 
   std::vector<storage::DataElement> descriptions;
   std::set<std::string> referenced_blobs = consolidation->referenced_blobs();
   BlobTransportController::GetDescriptions(
       consolidation.get(), kBlobStorageIPCThresholdBytes, &descriptions);
@@ skipping 18 matching lines @@
     const std::vector<IPC::PlatformFileForTransit>& file_handles,
     IPC::Sender* sender) {
   std::vector<storage::BlobItemBytesResponse> responses;
   ResponsesStatus status =
       GetResponses(uuid, requests, memory_handles, file_handles, &responses);
 
   switch (status) {
     case ResponsesStatus::BLOB_NOT_FOUND:
       // sender->Send(new BlobStorageMsg_CancelBuildingBlob(uuid,
       // IPCBlobCreationCancelCode::UNKNOWN));
+      CHECK(false) << "Could not find " << uuid << " Instance: " << this << ", "
+                   << base::PlatformThread::GetName();
       return;
     case ResponsesStatus::SHARED_MEMORY_MAP_FAILED:
       // This would happen if the renderer process doesn't have enough memory
       // to map the shared memory, which is possible if we don't have much
       // memory. If this scenario happens often, we could delay the response
       // until we have enough memory.  For now we just fail.
       CHECK(false) << "Unable to map shared memory to send blob " << uuid
                    << ".";
       break;
     case ResponsesStatus::SUCCESS:
       break;
   }
 
   sender->Send(new BlobStorageMsg_MemoryItemResponse(uuid, responses));
 }
 
 void BlobTransportController::OnCancel(
     const std::string& uuid,
     storage::IPCBlobCreationCancelCode code) {
-  DVLOG(1) << "Received blob cancel for blob " << uuid
+  LOG(ERROR) << "Received blob cancel for blob " << uuid
            << " with code: " << static_cast<int>(code);
   ReleaseBlobConsolidation(uuid);
 }
 
 void BlobTransportController::OnDone(const std::string& uuid) {
+
+  auto it = blob_storage_.find(uuid);
+  if (it != blob_storage_.end()) {
+
+    BlobConsolidation* consolidation = it->second.get();
+    if (consolidation->total_memory() > kBlobStorageIPCThresholdBytes) {
+      LOG(ERROR) << uuid << " got done for shared memory.";
+    }
+  }
   ReleaseBlobConsolidation(uuid);
 }
 
 // static
 void BlobTransportController::GetDescriptions(
     BlobConsolidation* consolidation,
     size_t max_data_population,
     std::vector<storage::DataElement>* out) {
   DCHECK(out->empty());
   DCHECK(consolidation);
@@ skipping 53 matching lines @@
     main_thread_runner_->PostTask(FROM_HERE,
                                   base::Bind(&DecChildProcessRefCount));
   }
   blob_storage_.clear();
 }
 
 void BlobTransportController::StoreBlobDataForRequests(
     const std::string& uuid,
     std::unique_ptr<BlobConsolidation> consolidation,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner) {
+
   if (!main_thread_runner_.get()) {
     main_thread_runner_ = std::move(main_runner);
   }
+  if (consolidation->total_memory() > kBlobStorageIPCThresholdBytes) {
+    LOG(ERROR) << uuid << " storing shared memory consolidation on "
+               << base::PlatformThread::GetName();
+  }
   blob_storage_[uuid] = std::move(consolidation);
 }
 
 BlobTransportController::ResponsesStatus BlobTransportController::GetResponses(
     const std::string& uuid,
     const std::vector<BlobItemBytesRequest>& requests,
     std::vector<SharedMemoryHandle>* memory_handles,
     const std::vector<IPC::PlatformFileForTransit>& file_handles,
     std::vector<BlobItemBytesResponse>* out) {
   DCHECK(out->empty());
@@ skipping 24 matching lines @@
         BlobItemBytesResponse& response = out->back();
         ReadStatus status = consolidation->ReadMemory(
             request.renderer_item_index, request.renderer_item_offset,
             request.size, response.allocate_mutable_data(request.size));
         DCHECK(status == ReadStatus::OK)
             << "Error reading from consolidated blob: "
             << static_cast<int>(status);
         break;
       }
       case IPCBlobItemRequestStrategy::SHARED_MEMORY: {
+        LOG(ERROR) << uuid << " got shared memory request on "
+            << base::PlatformThread::GetName();
         DCHECK_LT(request.handle_index, memory_handles->size())
             << "Invalid handle index.";
         SharedMemory* memory = opened_memory[request.handle_index];
         if (!memory) {
           SharedMemoryHandle& handle = (*memory_handles)[request.handle_index];
           DCHECK(SharedMemory::IsHandleValid(handle));
           std::unique_ptr<SharedMemory> shared_memory(
               new SharedMemory(handle, false));
           if (!shared_memory->Map(request.size))
             return ResponsesStatus::SHARED_MEMORY_MAP_FAILED;
           memory = shared_memory.get();
           opened_memory[request.handle_index] = shared_memory.release();
         }
         CHECK(memory->memory()) << "Couldn't map memory for blob transfer.";
         ReadStatus status = consolidation->ReadMemory(
             request.renderer_item_index, request.renderer_item_offset,
             request.size,
             static_cast<char*>(memory->memory()) + request.handle_offset);
-        DCHECK(status == ReadStatus::OK)
+        CHECK(status == ReadStatus::OK)
             << "Error reading from consolidated blob: "
             << static_cast<int>(status);
         break;
       }
       case IPCBlobItemRequestStrategy::FILE:
         NOTREACHED() << "TODO(dmurph): Not implemented.";
         break;
       case IPCBlobItemRequestStrategy::UNKNOWN:
         NOTREACHED();
         break;
     }
   }
   return ResponsesStatus::SUCCESS;
 }
 
 void BlobTransportController::ReleaseBlobConsolidation(
     const std::string& uuid) {
   if (blob_storage_.erase(uuid)) {
     main_thread_runner_->PostTask(FROM_HERE,
                                   base::Bind(&DecChildProcessRefCount));
   }
 }
 
 }  // namespace content