[Storage] Added tracing for blob creation

storage/browser/blob/blob_storage_context.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_storage_context.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
+#include "base/trace_event/trace_event.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "url/gurl.h"
 
 namespace storage {
 
 namespace {
 
 // We can't use GURL directly for these hash fragment manipulations
 // since it doesn't have specific knowlege of the BlobURL format. GURL
@@ skipping 58 matching lines @@
     const GURL& url) {
   BlobURLMap::iterator found =
       public_blob_urls_.find(BlobUrlHasRef(url) ? ClearBlobUrlRef(url) : url);
   if (found == public_blob_urls_.end())
     return scoped_ptr<BlobDataHandle>();
   return GetBlobDataFromUUID(found->second);
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob(
     BlobDataBuilder* external_builder) {
+  TRACE_EVENT0("Blob", "Context::AddFinishedBlob");
   StartBuildingBlob(external_builder->uuid_);
   BlobMap::iterator found = blob_map_.find(external_builder->uuid_);
   DCHECK(found != blob_map_.end());
   BlobMapEntry* entry = found->second;
   InternalBlobData::Builder* target_blob_builder = entry->data_builder.get();
   DCHECK(target_blob_builder);
 
   target_blob_builder->set_content_disposition(
       external_builder->content_disposition_);
   for (const auto& blob_item : external_builder->items_) {
@@ skipping 51 matching lines @@
 }
 
 void BlobStorageContext::StartBuildingBlob(const std::string& uuid) {
   DCHECK(!IsInUse(uuid) && !uuid.empty());
   blob_map_[uuid] = new BlobMapEntry(1, new InternalBlobData::Builder());
 }
 
 void BlobStorageContext::AppendBlobDataItem(
     const std::string& uuid,
     const storage::DataElement& ipc_data_element) {
+  TRACE_EVENT0("Blob", "Context::AppendBlobDataItem");
   DCHECK(IsBeingBuilt(uuid));
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return;
   BlobMapEntry* entry = found->second;
   if (entry->flags & EXCEEDED_MEMORY)
     return;
   InternalBlobData::Builder* target_blob_builder = entry->data_builder.get();
   DCHECK(target_blob_builder);
 
@@ skipping 19 matching lines @@
   entry->data = entry->data_builder->Build();
   entry->data_builder.reset();
   UMA_HISTOGRAM_COUNTS("Storage.Blob.ItemCount", entry->data->items().size());
   UMA_HISTOGRAM_BOOLEAN("Storage.Blob.ExceededMemory",
                         (entry->flags & EXCEEDED_MEMORY) == EXCEEDED_MEMORY);
   size_t total_memory = 0, nonshared_memory = 0;
   entry->data->GetMemoryUsage(&total_memory, &nonshared_memory);
   UMA_HISTOGRAM_COUNTS("Storage.Blob.TotalSize", total_memory / 1024);
   UMA_HISTOGRAM_COUNTS("Storage.Blob.TotalUnsharedSize",
                        nonshared_memory / 1024);
+  TRACE_COUNTER1("Blob", "MemoryStoreUsageBytes", memory_usage_);
 }
 
 void BlobStorageContext::CancelBuildingBlob(const std::string& uuid) {
   DCHECK(IsBeingBuilt(uuid));
   DecrementBlobRefCount(uuid);
 }
 
 void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end()) {
@@ skipping 252 matching lines @@
   if (found == blob_map_.end())
     return false;
   return found->second->IsBeingBuilt();
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
 }  // namespace storage