[Storage] Added tracing for blob creation

content/child/webblobregistry_impl.cc

 // Copyright 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 "content/child/webblobregistry_impl.h"
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
+#include "base/trace_event/trace_event.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
-#include "storage/common/data_element.h"
 #include "third_party/WebKit/public/platform/WebBlobData.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebThreadSafeData.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 
 using blink::WebBlobData;
 using blink::WebString;
 using blink::WebThreadSafeData;
 using blink::WebURL;
 
 namespace content {
 
 namespace {
 
 const size_t kLargeThresholdBytes = 250 * 1024;
 const size_t kMaxSharedMemoryBytes = 10 * 1024 * 1024;
 
 }  // namespace
 
 WebBlobRegistryImpl::WebBlobRegistryImpl(ThreadSafeSender* sender)
     : sender_(sender) {
+  // Record a dummy trace event on startup so the 'Storage' category shows up
+  // in the chrome://tracing viewer.

[michaeln, 2015/03/10 21:04:05]

got it, thnx for the comment

+  TRACE_EVENT0("Storage.Blob", "Init");
 }
 
 WebBlobRegistryImpl::~WebBlobRegistryImpl() {
 }
 
 void WebBlobRegistryImpl::registerBlobData(
     const blink::WebString& uuid, const blink::WebBlobData& data) {
+  TRACE_EVENT0("Storage.Blob", "RegisterBlobData");
   const std::string uuid_str(uuid.utf8());
 
   storage::DataElement data_buffer;
   data_buffer.SetToEmptyBytes();
 
   sender_->Send(new BlobHostMsg_StartBuilding(uuid_str));
   size_t i = 0;
   WebBlobData::Item data_item;
   while (data.itemAt(i++, data_item)) {
     // NOTE: data_item.length == -1 when we want to use the whole file.  This
@@ skipping 89 matching lines @@
                                          const blink::WebThreadSafeData& data,
                                          storage::DataElement* data_buffer) {
   size_t buffer_size = data_buffer->length();
   size_t data_size = data.size();
   DCHECK_NE(data_size, 0ul);
   if (buffer_size != 0 && buffer_size + data_size >= kLargeThresholdBytes) {
     FlushBlobItemBuffer(uuid_str, data_buffer);
     buffer_size = 0;
   }
   if (data_size >= kLargeThresholdBytes) {
+    TRACE_EVENT0("Storage.Blob", "SendOversizedBlobData");
     SendOversizedDataForBlob(uuid_str, data);
   } else {
     DCHECK_LT(buffer_size + data_size, kLargeThresholdBytes);
     data_buffer->AppendBytes(data.data(), data_size);
   }
 }
 
 void WebBlobRegistryImpl::SendOversizedDataForBlob(

[michaeln, 2015/03/10 21:04:05]

idk how strong the naming conventions are? you may want to change how these are
named to better match.

The labels are almost always are of the form "ClassName::MethodName", and when
there are more than one event in a method I remember seeing
"FooClass::BarMethod.1" and "FooClass::BarMethod.2". I think we should probably
follow that convention here and put both of these trace events in this method.

Category names usually don't use a dotted notation. Maybe just call this "blob"
or "Blob", but i see how that's overly generic and "Storage.Blob" may be a
better choice.

[dmurph, 2015/03/11 22:28:36]

I like "Blob" better.

     const std::string& uuid_str,
     const blink::WebThreadSafeData& data) {
   DCHECK_GE(data.size(), kLargeThresholdBytes);
   // We handle larger amounts of data via SharedMemory instead of
   // writing it directly to the IPC channel.
   size_t shared_memory_size = std::min(data.size(), kMaxSharedMemoryBytes);
   scoped_ptr<base::SharedMemory> shared_memory(
       ChildThreadImpl::AllocateSharedMemory(shared_memory_size, sender_.get()));
   CHECK(shared_memory.get());
   if (!shared_memory->Map(shared_memory_size))
     CHECK(false);
 
   size_t data_size = data.size();
   const char* data_ptr = data.data();
   while (data_size) {
+    TRACE_EVENT0("Storage.Blob", "SendOversizedBlobItem");
     size_t chunk_size = std::min(data_size, shared_memory_size);
     memcpy(shared_memory->memory(), data_ptr, chunk_size);
     sender_->Send(new BlobHostMsg_SyncAppendSharedMemory(
         uuid_str, shared_memory->handle(), chunk_size));
     data_size -= chunk_size;
     data_ptr += chunk_size;
   }
 }
 
 // ------ streams stuff -----
@@ skipping 58 matching lines @@
   DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_AbortBuilding(url));
 }
 
 void WebBlobRegistryImpl::unregisterStreamURL(const WebURL& url) {
   DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_Remove(url));
 }
 
 }  // namespace content