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 {
+namespace {

[abarth-chromium, 2013/09/13 17:38:18]

We usually have a blank line above anonymous namespaces.

[Philippe, 2013/09/16 11:47:21]

Done.

 
-static Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset)
+// Used for histograms.

[abarth-chromium, 2013/09/13 17:38:18]

No need for this comment.

[Philippe, 2013/09/16 11:47:21]

Done.

+enum ActionUponResourceRequest {
+    LoadResource = 0,
+    RevalidateResource = 1,
+    UseResourceFromCache = 2,
+    ActionUponResourceRequestBoundaryValue = 3,

[abarth-chromium, 2013/09/13 17:38:18]

No need to list these numbers explicitly.

What is a boundary value?  How about NumberOfResourceRequestActions?

[Philippe, 2013/09/16 11:47:21]

Boundary value is the terminology used in HistogramSupport.h. I agree it's not
very clear :)

+};
+
+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);
     }

[abarth-chromium, 2013/09/13 17:38:18]

Why doesn't the compiler complain that you're missing an enum value in this
switch?

[Philippe, 2013/09/16 11:47:21]

We don't provide any specific warning flags (on Linux/Android at least). The
only thing we do is to disable specific warning flags:
-Wno-unused-parameter, -Wno-missing-field-initializers, -Wno-format,
-Wno-unused-result, -Wno-c++0x-compat, -Wno-deprecated

As you can imagine adding -Wswitch-enum for non-Chromium code causes millions of
warning messages (turned into errors). We don't seem to distinguish Blink flags
from other third-party flags. I would expect that enabling certain compile flags
on Blink would be just as hard as on other third-party projects but
progressively enabling some of them in certain parts of the tree might make
sense now in my opinion since we own Blink. I expect that this would catch quite
a few potential bugs. For instance I remember once that I got bitten in Chromium
because I had forgotten to return a value in a non-void function (without even
any branch). This compiled just fine unfortunately.

This is slightly off-topic obviously :)

For this particular case I'm letting the ASSERT_NOT_REACHED() do the job on line
115 if you don't mind.

[Philippe, 2013/09/16 14:09:09]

Correction, the build does fail with Clang at least. So I added a new case where
it was needed.

 
     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:
@@ skipping 13 matching lines @@
         return ResourceLoadPriorityLow;
     case Resource::TextTrack:
         return ResourceLoadPriorityLow;
     case Resource::Shader:
         return ResourceLoadPriorityMedium;
     }
     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 360 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(
+            "Renderer.ResourceFetcher.ActionUponResourceRequest", LoadResource,

[abarth-chromium, 2013/09/13 17:38:18]

Renderer -> WebCore

[Philippe, 2013/09/16 11:47:21]

Done.

+            ActionUponResourceRequestBoundaryValue);
         break;
     case Revalidate:
         resource = revalidateResource(request, resource.get());
+        HistogramSupport::histogramEnumeration(
+            "Renderer.ResourceFetcher.ActionUponResourceRequest", RevalidateResource,
+            ActionUponResourceRequestBoundaryValue);
         break;
     case Use:
         resource->updateForAccess();
         notifyLoadedFromMemoryCache(resource.get());
+        HistogramSupport::histogramEnumeration(
+            "Renderer.ResourceFetcher.ActionUponResourceRequest", UseResourceFromCache,
+            ActionUponResourceRequestBoundaryValue);
+        HistogramSupport::histogramEnumeration(
+            "Renderer.ResourceFetcher.ResourceHasClientUponCacheHit", resource->hasClients(), 2);
+        HistogramSupport::histogramEnumeration(
+            "Renderer.ResourceFetcher.ResourceTypeUponCacheHit", resource->type(),
+            Resource::TypeBoundaryValue);
         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;
 }
 
 }