Loading: pass minimum information to Resource::resourceTypeToString()

third_party/WebKit/Source/core/fetch/Resource.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) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 36 matching lines @@
 #include "public/platform/WebSecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
 #include <memory>
 #include <stdint.h>
+#include <type_traits>

[Yoav Weiss, 2016/12/15 14:53:54]

Why is this header needed?

[Takashi Toyoshima, 2016/12/19 05:47:48]

Oh, I mistakenly use this but the right header for static_assert() seems to be
<cassert>.

 
 namespace blink {
 
 // These response headers are not copied from a revalidated response to the
 // cached response headers. For compatibility, this list is based on Chromium's
 // net/http/http_response_headers.cc.
 const char* const headersToIgnoreAfterRevalidation[] = {
     "allow",
     "connection",
     "etag",
@@ skipping 850 matching lines @@
   WebMemoryAllocatorDump* overheadDump =
       memoryDump->createMemoryAllocatorDump(overheadName);
   overheadDump->addScalar("size", "bytes", overheadSize());
   memoryDump->addSuballocation(
       overheadDump->guid(), String(WTF::Partitions::kAllocatedObjectPoolName));
 }
 
 String Resource::getMemoryDumpName() const {
   return String::format(
       "web_cache/%s_resources/%ld",
-      resourceTypeToString(getType(), options().initiatorInfo), m_identifier);
+      resourceTypeToString(getType(), options().initiatorInfo.name),
+      m_identifier);
 }
 
 void Resource::setCachePolicyBypassingCache() {
   m_resourceRequest.setCachePolicy(WebCachePolicy::BypassingCache);
 }
 
 void Resource::setLoFiStateOff() {
   m_resourceRequest.setLoFiState(WebURLRequest::LoFiOff);
 }
 
@@ skipping 81 matching lines @@
          m_resourceRequest.url().getString().length() * 2;
 }
 
 void Resource::didChangePriority(ResourceLoadPriority loadPriority,
                                  int intraPriorityValue) {
   m_resourceRequest.setPriority(loadPriority, intraPriorityValue);
   if (m_loader)
     m_loader->didChangePriority(loadPriority, intraPriorityValue);
 }
 
 static const char* initatorTypeNameToString(

[yhirano, 2016/12/19 06:23:08]

Not related to this change but this name should be initiatorTypeNameToString.

[Takashi Toyoshima, 2016/12/19 06:59:01]

Done.

     const AtomicString& initiatorTypeName) {
   if (initiatorTypeName == FetchInitiatorTypeNames::css)
     return "CSS resource";
   if (initiatorTypeName == FetchInitiatorTypeNames::document)
     return "Document";
   if (initiatorTypeName == FetchInitiatorTypeNames::icon)
     return "Icon";
   if (initiatorTypeName == FetchInitiatorTypeNames::internal)
     return "Internal resource";
   if (initiatorTypeName == FetchInitiatorTypeNames::link)
     return "Link element resource";
   if (initiatorTypeName == FetchInitiatorTypeNames::processinginstruction)
     return "Processing instruction";
   if (initiatorTypeName == FetchInitiatorTypeNames::texttrack)
     return "Text track";
   if (initiatorTypeName == FetchInitiatorTypeNames::xml)
     return "XML resource";
   if (initiatorTypeName == FetchInitiatorTypeNames::xmlhttprequest)
     return "XMLHttpRequest";
 
+  static_assert(
+      FetchInitiatorTypeNames::FetchInitiatorTypeNamesCount == 12,
+      "New FetchInitiatorTypeNames should be handled correctly here.");
+
   return "Resource";
 }
 
 const char* Resource::resourceTypeToString(
     Type type,
-    const FetchInitiatorInfo& initiatorInfo) {
+    const AtomicString& fetchInitiatorName) {
   switch (type) {
     case Resource::MainResource:
       return "Main resource";
     case Resource::Image:
       return "Image";
     case Resource::CSSStyleSheet:
       return "CSS stylesheet";
     case Resource::Script:
       return "Script";
     case Resource::Font:
       return "Font";
     case Resource::Raw:
-      return initatorTypeNameToString(initiatorInfo.name);
+      return initatorTypeNameToString(fetchInitiatorName);
     case Resource::SVGDocument:
       return "SVG document";
     case Resource::XSLStyleSheet:
       return "XSL stylesheet";
     case Resource::LinkPrefetch:
       return "Link prefetch resource";
     case Resource::TextTrack:
       return "Text track";
     case Resource::ImportResource:
       return "Imported resource";
     case Resource::Media:
       return "Media";
     case Resource::Manifest:
       return "Manifest";
     case Resource::Mock:
       return "Mock";
   }
   NOTREACHED();
-  return initatorTypeNameToString(initiatorInfo.name);
+  return initatorTypeNameToString(fetchInitiatorName);
 }
 
 bool Resource::shouldBlockLoadEvent() const {
   return !m_linkPreload && isLoadEventBlockingResourceType();
 }
 
 bool Resource::isLoadEventBlockingResourceType() const {
   switch (m_type) {
     case Resource::MainResource:
     case Resource::Image:
@@ skipping 10 matching lines @@
     case Resource::Media:
     case Resource::Manifest:
     case Resource::Mock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink