[Not for review] record detailed time breakdown of SW related requests.

third_party/WebKit/Source/platform/blob/BlobRegistry.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/blob/BlobRegistry.h"
 
+#include <memory>
 #include "platform/CrossThreadFunctional.h"
+#include "platform/Histogram.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/blob/BlobData.h"
 #include "platform/blob/BlobURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/URLSecurityOriginMap.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebBlobData.h"
 #include "public/platform/WebBlobRegistry.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Assertions.h"
+#include "wtf/CurrentTime.h"
 #include "wtf/HashMap.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/Threading.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
-#include <memory>
 
 namespace blink {
 
 class BlobOriginMap : public URLSecurityOriginMap {
  public:
   BlobOriginMap();
   SecurityOrigin* getOrigin(const KURL&) override;
 };
 
 static WebBlobRegistry* getBlobRegistry() {
@@ skipping 45 matching lines @@
                                          PassRefPtr<BlobDataHandle> handle) {
   saveToOriginMap(origin, url);
   getBlobRegistry()->registerPublicBlobURL(url, handle->uuid());
 }
 
 void BlobRegistry::revokePublicBlobURL(const KURL& url) {
   removeFromOriginMap(url);
   getBlobRegistry()->revokePublicBlobURL(url);
 }
 
-static void registerStreamURLTask(const KURL& url, const String& type) {
+static void registerStreamURLTask(const KURL& url,
+                                  const String& type,
+                                  double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, hist,
+                      ("SWF.E1.Stream.RegisterStreamURLTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->registerStreamURL(url, type);
 }
 
 void BlobRegistry::registerStreamURL(const KURL& url, const String& type) {
   if (isMainThread())
-    registerStreamURLTask(url, type);
+    registerStreamURLTask(url, type, 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(&registerStreamURLTask, url, type));
+        BLINK_FROM_HERE, crossThreadBind(&registerStreamURLTask, url, type,
+                                         monotonicallyIncreasingTime()));
 }
 
-static void registerStreamURLFromTask(const KURL& url, const KURL& srcURL) {
+static void registerStreamURLFromTask(const KURL& url,
+                                      const KURL& srcURL,
+                                      double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(
+      CustomCountHistogram, hist,
+      ("SWF.E1.Stream.registerStreamURLFromTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->registerStreamURL(url, srcURL);
 }
 
 void BlobRegistry::registerStreamURL(SecurityOrigin* origin,
                                      const KURL& url,
                                      const KURL& srcURL) {
   saveToOriginMap(origin, url);
 
   if (isMainThread())
-    registerStreamURLFromTask(url, srcURL);
+    registerStreamURLFromTask(url, srcURL, 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE,
-        crossThreadBind(&registerStreamURLFromTask, url, srcURL));
+        crossThreadBind(&registerStreamURLFromTask, url, srcURL,
+                        monotonicallyIncreasingTime()));
 }
 
 static void addDataToStreamTask(const KURL& url,
-                                PassRefPtr<RawData> streamData) {
+                                PassRefPtr<RawData> streamData,
+                                double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, hist,
+                      ("SWF.E2.Stream.AddDataToStreamTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
+
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->addDataToStream(url, streamData->data(), streamData->length());
 }
 
 void BlobRegistry::addDataToStream(const KURL& url,
                                    PassRefPtr<RawData> streamData) {
   if (isMainThread())
-    addDataToStreamTask(url, std::move(streamData));
+    addDataToStreamTask(url, std::move(streamData), 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE,
-        crossThreadBind(&addDataToStreamTask, url, std::move(streamData)));
+        crossThreadBind(&addDataToStreamTask, url, std::move(streamData),
+                        monotonicallyIncreasingTime()));
 }
 
-static void flushStreamTask(const KURL& url) {
+static void flushStreamTask(const KURL& url, double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, hist,
+                      ("SWF.E3.Stream.FlushStreamTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
+
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->flushStream(url);
 }
 
 void BlobRegistry::flushStream(const KURL& url) {
   if (isMainThread())
-    flushStreamTask(url);
+    flushStreamTask(url, 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(&flushStreamTask, url));
+        BLINK_FROM_HERE,
+        crossThreadBind(&flushStreamTask, url, monotonicallyIncreasingTime()));
 }
 
-static void finalizeStreamTask(const KURL& url) {
+static void finalizeStreamTask(const KURL& url, double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, hist,
+                      ("SWF.E4.Stream.FinalizeStreamTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->finalizeStream(url);
 }
 
 void BlobRegistry::finalizeStream(const KURL& url) {
   if (isMainThread())
-    finalizeStreamTask(url);
+    finalizeStreamTask(url, 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(&finalizeStreamTask, url));
+        BLINK_FROM_HERE, crossThreadBind(&finalizeStreamTask, url,
+                                         monotonicallyIncreasingTime()));
 }
 
-static void abortStreamTask(const KURL& url) {
+static void abortStreamTask(const KURL& url, double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(CustomCountHistogram, hist,
+                      ("SWF.E5.Stream.AbortStreamTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->abortStream(url);
 }
 
 void BlobRegistry::abortStream(const KURL& url) {
   if (isMainThread())
-    abortStreamTask(url);
+    abortStreamTask(url, 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(&abortStreamTask, url));
+        BLINK_FROM_HERE,
+        crossThreadBind(&abortStreamTask, url, monotonicallyIncreasingTime()));
 }
 
-static void unregisterStreamURLTask(const KURL& url) {
+static void unregisterStreamURLTask(const KURL& url, double postTaskTime) {
+  int value =
+      static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000);
+  DEFINE_STATIC_LOCAL(
+      CustomCountHistogram, hist,
+      ("SWF.E6.Stream.UnregisterStreamURLTask", 0, 10000000, 50));
+  if (postTaskTime != 0)
+    hist.count(value);
   if (WebBlobRegistry* registry = getBlobRegistry())
     registry->unregisterStreamURL(url);
 }
 
 void BlobRegistry::unregisterStreamURL(const KURL& url) {
   removeFromOriginMap(url);
 
   if (isMainThread())
-    unregisterStreamURLTask(url);
+    unregisterStreamURLTask(url, 0);
   else
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, crossThreadBind(&unregisterStreamURLTask, url));
+        BLINK_FROM_HERE, crossThreadBind(&unregisterStreamURLTask, url,
+                                         monotonicallyIncreasingTime()));
 }
 
 BlobOriginMap::BlobOriginMap() {
   SecurityOrigin::setMap(this);
 }
 
 SecurityOrigin* BlobOriginMap::getOrigin(const KURL& url) {
   if (url.protocolIs("blob"))
     return originMap()->get(url.getString());
   return 0;
 }
 
 }  // namespace blink