Add histograms to ResourceFetcher to measure memory cache hit rate.

Source/core/fetch/ResourceFetcher.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 41 matching lines @@
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/PingLoader.h"
 #include "core/loader/UniqueIdentifier.h"
 #include "core/loader/appcache/ApplicationCacheHost.h"
 #include "core/page/ContentSecurityPolicy.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/Frame.h"
 #include "core/page/Performance.h"
 #include "core/page/ResourceTimingInfo.h"
 #include "core/page/Settings.h"
+#include "core/platform/HistogramSupport.h"
 #include "core/platform/Logging.h"
 #include "core/platform/chromium/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURL.h"
 #include "weborigin/SecurityOrigin.h"
 #include "weborigin/SecurityPolicy.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 #define PRELOAD_DEBUG 0
 
 namespace WebCore {
 
-static Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset)
+namespace {
+
+enum ActionUponResourceRequest {
+    LoadResource,
+    RevalidateResource,
+    UseResourceFromCache,
+    NumberOfResourceRequestActions,
+};
+
+Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset)
 {
     switch (type) {
     case Resource::Image:
         return new ImageResource(request);
     case Resource::CSSStyleSheet:
         return new CSSStyleSheetResource(request, charset);
     case Resource::Script:
         return new ScriptResource(request, charset);
     case Resource::SVGDocument:
         return new DocumentResource(request, Resource::SVGDocument);
     case Resource::Font:
         return new FontResource(request);
     case Resource::Raw:
     case Resource::MainResource:
         return new RawResource(request, type);
     case Resource::XSLStyleSheet:
         return new XSLStyleSheetResource(request);
     case Resource::LinkPrefetch:
         return new Resource(request, Resource::LinkPrefetch);
     case Resource::LinkSubresource:
         return new Resource(request, Resource::LinkSubresource);
     case Resource::TextTrack:
         return new TextTrackResource(request);
     case Resource::Shader:
         return new ShaderResource(request);
     case Resource::ImportResource:
         return new RawResource(request, type);
+    case Resource::NumberOfTypes:
+        ASSERT_NOT_REACHED();
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-static ResourceLoadPriority loadPriority(Resource::Type type, const FetchRequest& request)
+ResourceLoadPriority loadPriority(Resource::Type type, const FetchRequest& request)
 {
     if (request.priority() != ResourceLoadPriorityUnresolved)
         return request.priority();
 
     switch (type) {
     case Resource::MainResource:
         return ResourceLoadPriorityVeryHigh;
     case Resource::CSSStyleSheet:
         return ResourceLoadPriorityHigh;
     case Resource::Script:
     case Resource::Font:
     case Resource::Raw:
     case Resource::ImportResource:
         return ResourceLoadPriorityMedium;
     case Resource::Image:
         return request.forPreload() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityLow;
     case Resource::XSLStyleSheet:
         return ResourceLoadPriorityHigh;
     case Resource::SVGDocument:
         return ResourceLoadPriorityLow;
     case Resource::LinkPrefetch:
         return ResourceLoadPriorityVeryLow;
     case Resource::LinkSubresource:
         return ResourceLoadPriorityLow;
     case Resource::TextTrack:
         return ResourceLoadPriorityLow;
     case Resource::Shader:
         return ResourceLoadPriorityMedium;
+    case Resource::NumberOfTypes:
+        ASSERT_NOT_REACHED();
     }
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
-static Resource* resourceFromDataURIRequest(const ResourceRequest& request)
+Resource* resourceFromDataURIRequest(const ResourceRequest& request)
 {
     const KURL& url = request.url();
     ASSERT(url.protocolIsData());
 
     WebKit::WebString mimetype;
     WebKit::WebString charset;
     RefPtr<SharedBuffer> data = PassRefPtr<SharedBuffer>(WebKit::Platform::current()->parseDataURL(url, mimetype, charset));
     if (!data)
         return 0;
     ResourceResponse response(url, mimetype, data->size(), charset, String());
 
     Resource* resource = createResource(Resource::Image, request, charset);
     resource->responseReceived(response);
     // FIXME: AppendData causes an unnecessary memcpy.
     if (data->size())
         resource->appendData(data->data(), data->size());
     resource->finish();
     return resource;
 }
 
+} // namespace
+
 ResourceFetcher::ResourceFetcher(DocumentLoader* documentLoader)
     : m_document(0)
     , m_documentLoader(documentLoader)
     , m_requestCount(0)
     , m_garbageCollectDocumentResourcesTimer(this, &ResourceFetcher::garbageCollectDocumentResourcesTimerFired)
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
 {
 }
@@ skipping 176 matching lines @@
             // These resources can corrupt only the frame's pixels.
             treatment = TreatAsPassiveContent;
             break;
 
         case Resource::MainResource:
         case Resource::LinkPrefetch:
         case Resource::LinkSubresource:
             // These cannot affect the current document.
             treatment = TreatAsAlwaysAllowedContent;
             break;
+        case Resource::NumberOfTypes:
+            ASSERT_NOT_REACHED();
         }
     }
     if (treatment == TreatAsActiveContent) {
         if (Frame* f = frame()) {
             if (!f->loader()->mixedContentChecker()->canRunInsecureContent(m_document->securityOrigin(), url))
                 return false;
         }
     } else if (treatment == TreatAsPassiveContent) {
         if (Frame* f = frame()) {
             Frame* top = f->tree()->top();
@@ skipping 40 matching lines @@
             return false;
         }
         break;
     case Resource::SVGDocument:
     case Resource::XSLStyleSheet:
         if (!m_document->securityOrigin()->canRequest(url)) {
             printAccessDeniedMessage(url);
             return false;
         }
         break;
+    case Resource::NumberOfTypes:
+        ASSERT_NOT_REACHED();
     }
 
     switch (type) {
     case Resource::XSLStyleSheet:
         if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowScriptFromSource(url))
             return false;
         break;
     case Resource::Script:
     case Resource::ImportResource:
         if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowScriptFromSource(url))
@@ skipping 27 matching lines @@
     case Resource::Raw:
     case Resource::LinkPrefetch:
     case Resource::LinkSubresource:
         break;
     case Resource::TextTrack:
         // Cues aren't called out in the CPS spec yet, but they only work with a media element
         // so use the media policy.
         if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowMediaFromSource(url))
             return false;
         break;
+    case Resource::NumberOfTypes:
+        ASSERT_NOT_REACHED();
     }
 
     // Last of all, check for insecure content. We do this last so that when
     // folks block insecure content with a CSP policy, they don't get a warning.
     // They'll still get a warning in the console about CSP blocking the load.
 
     // FIXME: Should we consider forPreload here?
     if (!checkInsecureContent(type, url, options.mixedContentBlockingTreatment))
         return false;
 
@@ skipping 57 matching lines @@
     // See if we can use an existing resource from the cache.
     ResourcePtr<Resource> resource = memoryCache()->resourceForURL(url);
 
     const RevalidationPolicy policy = determineRevalidationPolicy(type, request.mutableResourceRequest(), request.forPreload(), resource.get(), request.defer());
     switch (policy) {
     case Reload:
         memoryCache()->remove(resource.get());
         // Fall through
     case Load:
         resource = loadResource(type, request, request.charset());
+        HistogramSupport::histogramEnumeration(
+            "WebCore.ResourceFetcher.ActionUponResourceRequest", LoadResource,
+            NumberOfResourceRequestActions);
         break;
     case Revalidate:
         resource = revalidateResource(request, resource.get());
+        HistogramSupport::histogramEnumeration(
+            "WebCore.ResourceFetcher.ActionUponResourceRequest", RevalidateResource,
+            NumberOfResourceRequestActions);
         break;
     case Use:
         resource->updateForAccess();
         notifyLoadedFromMemoryCache(resource.get());
+        HistogramSupport::histogramEnumeration(
+            "WebCore.ResourceFetcher.ActionUponResourceRequest", UseResourceFromCache,
+            NumberOfResourceRequestActions);
+        HistogramSupport::histogramEnumeration(
+            "WebCore.ResourceFetcher.ResourceHasClientUponCacheHit", resource->hasClients(), 2);
+        HistogramSupport::histogramEnumeration(
+            "WebCore.ResourceFetcher.ResourceTypeUponCacheHit", resource->type(),
+            Resource::NumberOfTypes);
         break;
     }
 
     if (!resource)
         return 0;
 
     if (policy != Use)
         resource->setIdentifier(createUniqueIdentifier());
 
     if (!request.forPreload() || policy != Use) {
@@ skipping 749 matching lines @@
 }
 #endif
 
 const ResourceLoaderOptions& ResourceFetcher::defaultResourceOptions()
 {
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck, CheckContentSecurityPolicy, UseDefaultOriginRestrictionsForType, DocumentContext));
     return options;
 }
 
 }