PerformanceMonitor: do not maintain a vector of frames in the monitor, single ExecutionContext memb…

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 28 matching lines @@
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #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 kAmbugiousAttribution[] = "multiple-contexts";
+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 kCrossOriginAttribution[] = "cross-origin-unreachable";
 
 namespace blink {
 
 namespace {
 
 String getFrameAttribute(HTMLFrameOwnerElement* frameOwner,
@@ skipping 99 matching lines @@
       frame2->securityContext()->getSecurityOrigin();
   return securityOrigin1->canAccess(securityOrigin2);
 }
 
 /**
  * Report sanitized name based on cross-origin policy.
  * See detailed Security doc here: http://bit.ly/2duD3F7
  */
 // static
 std::pair<String, DOMWindow*> Performance::sanitizedAttribution(
-    const HeapHashSet<Member<Frame>>& frames,
+    ExecutionContext* taskContext,
+    bool hasMultipleContexts,
     Frame* observerFrame) {
-  if (frames.size() == 0) {
+  if (hasMultipleContexts) {
+    // Unable to attribute, multiple script execution contents were involved.
+    return std::make_pair(kAmbiguousAttribution, nullptr);
+  }
+
+  if (!taskContext || !taskContext->isDocument() ||
+      !toDocument(taskContext)->frame()) {
     // Unable to attribute as no script was involved.
     return std::make_pair(kUnknownAttribution, nullptr);
   }
-  if (frames.size() > 1) {
-    // Unable to attribute, multiple script execution contents were involved.
-    return std::make_pair(kAmbugiousAttribution, nullptr);
-  }
+
   // Exactly one culprit location, attribute based on origin boundary.
-  DCHECK_EQ(1u, frames.size());
-  Frame* culpritFrame = *frames.begin();
+  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());
   }
   // 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,
                           lastCrossOriginFrame->domWindow());
   }
   if (observerFrame->tree().isDescendantOf(culpritFrame)) {
     return std::make_pair(kAncestorAttribution, nullptr);
   }
   return std::make_pair(kCrossOriginAttribution, nullptr);
 }
 
-void Performance::reportLongTask(
-    double startTime,
-    double endTime,
-    const HeapHashSet<Member<Frame>>& contextFrames) {
-  std::pair<String, DOMWindow*> attribution =
-      Performance::sanitizedAttribution(contextFrames, frame());
+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