Add more detail to same-origin attribution indicating self|ancestor|descendant

third_party/WebKit/Source/core/timing/Performance.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel 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.
@@ skipping 30 matching lines @@
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/origin_trials/OriginTrials.h"
 #include "core/timing/PerformanceTiming.h"
 
 static const double kLongTaskThreshold = 0.05;
 
 static const char kUnknownAttribution[] = "unknown";
 static const char kAmbiguousAttribution[] = "multiple-contexts";
 static const char kSameOriginAttribution[] = "same-origin";
-static const char kAncestorAttribution[] = "cross-origin-ancestor";
-static const char kDescendantAttribution[] = "cross-origin-descendant";
+static const char kSameOriginSelfAttribution[] = "same-origin-self";
+static const char kSameOriginAncestorAttribution[] = "same-origin-ancestor";
+static const char kSameOriginDescendantAttribution[] = "same-origin-descendant";
+static const char kCrossOriginAncestorAttribution[] = "cross-origin-ancestor";
+static const char kCrossOriginDescendantAttribution[] =
+    "cross-origin-descendant";
 static const char kCrossOriginAttribution[] = "cross-origin-unreachable";
 
 namespace blink {
 
 namespace {
 
 String getFrameAttribute(HTMLFrameOwnerElement* frameOwner,
                          const QualifiedName& attrName,
                          bool truncate) {
   String attrValue;
   if (frameOwner->hasAttribute(attrName)) {
     attrValue = frameOwner->getAttribute(attrName);
     if (truncate && attrValue.length() > 100)
       attrValue = attrValue.substring(0, 100);  // Truncate to 100 chars
   }
   return attrValue;
 }
 
+const char* sameOriginAttribution(Frame* observerFrame, Frame* culpritFrame) {
+  if (observerFrame == culpritFrame)
+    return kSameOriginSelfAttribution;
+  if (observerFrame->tree().isDescendantOf(culpritFrame))
+    return kSameOriginAncestorAttribution;
+  if (culpritFrame->tree().isDescendantOf(observerFrame))
+    return kSameOriginDescendantAttribution;
+  return kSameOriginAttribution;
+}
+
 }  // namespace
 
 static double toTimeOrigin(LocalFrame* frame) {
   if (!frame)
     return 0.0;
 
   Document* document = frame->document();
   if (!document)
     return 0.0;
 
@@ skipping 97 matching lines @@
       !toDocument(taskContext)->frame()) {
     // Unable to attribute as no script was involved.
     return std::make_pair(kUnknownAttribution, nullptr);
   }
 
   // Exactly one culprit location, attribute based on origin boundary.
   Frame* culpritFrame = toDocument(taskContext)->frame();
   DCHECK(culpritFrame);
   if (canAccessOrigin(observerFrame, culpritFrame)) {
     // From accessible frames or same origin, return culprit location URL.
-    return std::make_pair(kSameOriginAttribution, culpritFrame->domWindow());
+    return std::make_pair(sameOriginAttribution(observerFrame, culpritFrame),
+                          culpritFrame->domWindow());
   }
   // For cross-origin, if the culprit is the descendant or ancestor of
   // observer then indicate the *closest* cross-origin frame between
   // the observer and the culprit, in the corresponding direction.
   if (culpritFrame->tree().isDescendantOf(observerFrame)) {
     // If the culprit is a descendant of the observer, then walk up the tree
     // from culprit to observer, and report the *last* cross-origin (from
     // observer) frame.  If no intermediate cross-origin frame is found, then
     // report the culprit directly.
     Frame* lastCrossOriginFrame = culpritFrame;
     for (Frame* frame = culpritFrame; frame != observerFrame;
          frame = frame->tree().parent()) {
       if (!canAccessOrigin(observerFrame, frame)) {
         lastCrossOriginFrame = frame;
       }
     }
-    return std::make_pair(kDescendantAttribution,
+    return std::make_pair(kCrossOriginDescendantAttribution,
                           lastCrossOriginFrame->domWindow());
   }
   if (observerFrame->tree().isDescendantOf(culpritFrame)) {
-    return std::make_pair(kAncestorAttribution, nullptr);
+    return std::make_pair(kCrossOriginAncestorAttribution, nullptr);
   }
   return std::make_pair(kCrossOriginAttribution, nullptr);
 }
 
 void Performance::reportLongTask(double startTime,
                                  double endTime,
                                  ExecutionContext* taskContext,
                                  bool hasMultipleContexts) {
   std::pair<String, DOMWindow*> attribution = Performance::sanitizedAttribution(
       taskContext, hasMultipleContexts, frame());
   DOMWindow* culpritDomWindow = attribution.second;
   if (!culpritDomWindow || !culpritDomWindow->document() ||
       !culpritDomWindow->document()->localOwner()) {
     addLongTaskTiming(startTime, endTime, attribution.first, "", "", "");
   } else {
     HTMLFrameOwnerElement* frameOwner =
         culpritDomWindow->document()->localOwner();
     addLongTaskTiming(startTime, endTime, attribution.first,
                       getFrameAttribute(frameOwner, HTMLNames::srcAttr, false),
                       getFrameAttribute(frameOwner, HTMLNames::idAttr, false),
                       getFrameAttribute(frameOwner, HTMLNames::nameAttr, true));
   }
 }
 
 }  // namespace blink