Use AtomicString for PerformanceEntry::name

This CL changes the name of a PerformanceEntry to become a name. It
should be noted that in general performance entries can be accessed from
main or worker threads, so some care is needed. An exception to this is
paint and longtask entries, and appropriate DCHECKs were added for those
cases.

Assessment of this change:
Speed: AtomicString comparisons are faster but this CL increased the
number of conversions between string types. So overall unclear, but
likely insignificant speed changes.
Memory: PerformanceEntry names are now shared so the memory usage
should be improved by this change.
Code complexity: increased (AtomicStrings are IMO harder to reason about
than slightly simpler Strings).

Bug: 852050
Change-Id: Iaee67c6bcd6123851a0f6657d12fb6b2c61cb5fc
Reviewed-on: https://chromium-review.googlesource.com/1153608Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: Timothy Dresser <tdresser@chromium.org>
Commit-Queue: Nicolás Peña Moreno <npm@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579609}

third_party/blink/renderer/core/frame/performance_monitor.cc

@@ -208,7 +208,7 @@ void PerformanceMonitor::Did(const probe::ExecuteScript& probe) {
   if (probe.Duration() <= kLongTaskSubTaskThreshold)
     return;
   std::unique_ptr<SubTaskAttribution> sub_task_attribution =
-      SubTaskAttribution::Create(String("script-run"),
+      SubTaskAttribution::Create(AtomicString("script-run"),
                                  probe.context->Url().GetString(),
                                  probe.CaptureStartTime(), probe.Duration());
   sub_task_attributions_.push_back(std::move(sub_task_attribution));
@@ -266,7 +266,7 @@ void PerformanceMonitor::Did(const probe::V8Compile& probe) {
 
   std::unique_ptr<SubTaskAttribution> sub_task_attribution =
       SubTaskAttribution::Create(
-          String("script-compile"),
+          AtomicString("script-compile"),
           String::Format("%s(%d, %d)", probe.file_name.Utf8().data(),
                          probe.line, probe.column),
           v8_compile_start_time_, v8_compile_duration);

third_party/blink/renderer/core/timing/performance.cc

@@ -230,7 +230,7 @@ PerformanceEntryVector Performance::getEntriesByType(
 }
 
 PerformanceEntryVector Performance::getEntriesByName(
-    const String& name,
+    const AtomicString& name,
     const AtomicString& entry_type) {
   PerformanceEntryVector entries;
   PerformanceEntry::EntryType type =
@@ -545,7 +545,7 @@ bool Performance::IsResourceTimingBufferFull() {
 void Performance::AddLongTaskTiming(
     TimeTicks start_time,
     TimeTicks end_time,
-    const String& name,
+    const AtomicString& name,
     const String& frame_src,
     const String& frame_id,
     const String& frame_name,
@@ -567,7 +567,7 @@ void Performance::AddLongTaskTiming(
 }
 
 PerformanceMark* Performance::mark(ScriptState* script_state,
-                                   const String& mark_name,
+                                   const AtomicString& mark_name,
                                    ExceptionState& exception_state) {
   DoubleOrPerformanceMarkOptions startOrOptions;
   return this->mark(script_state, mark_name, startOrOptions, exception_state);
@@ -575,7 +575,7 @@ PerformanceMark* Performance::mark(ScriptState* script_state,
 
 PerformanceMark* Performance::mark(
     ScriptState* script_state,
-    const String& mark_name,
+    const AtomicString& mark_name,
     DoubleOrPerformanceMarkOptions& start_time_or_mark_options,
     ExceptionState& exception_state) {
   if (!RuntimeEnabledFeatures::CustomUserTimingEnabled()) {
@@ -610,14 +610,14 @@ PerformanceMark* Performance::mark(
   return performance_mark;
 }
 
-void Performance::clearMarks(const String& mark_name) {
+void Performance::clearMarks(const AtomicString& mark_name) {
   if (!user_timing_)
     user_timing_ = UserTiming::Create(*this);
   user_timing_->ClearMarks(mark_name);
 }
 
 PerformanceMeasure* Performance::measure(ScriptState* script_state,
-                                         const String& measure_name,
+                                         const AtomicString& measure_name,
                                          ExceptionState& exception_state) {
   return measureInternal(script_state, measure_name,
                          NativeValueTraits<StringOrDouble>::NullValue(),
@@ -628,7 +628,7 @@ PerformanceMeasure* Performance::measure(ScriptState* script_state,
 
 PerformanceMeasure* Performance::measure(
     ScriptState* script_state,
-    const String& measure_name,
+    const AtomicString& measure_name,
     const StringOrDoubleOrPerformanceMeasureOptions& start_or_options,
     ExceptionState& exception_state) {
   return measureInternal(script_state, measure_name, start_or_options,
@@ -638,7 +638,7 @@ PerformanceMeasure* Performance::measure(
 
 PerformanceMeasure* Performance::measure(
     ScriptState* script_state,
-    const String& measure_name,
+    const AtomicString& measure_name,
     const StringOrDoubleOrPerformanceMeasureOptions& start_or_options,
     const StringOrDouble& end,
     ExceptionState& exception_state) {
@@ -665,7 +665,7 @@ PerformanceMeasure* Performance::measure(
 // distinguish between (null or undefined) and empty.
 PerformanceMeasure* Performance::measureInternal(
     ScriptState* script_state,
-    const String& measure_name,
+    const AtomicString& measure_name,
     const StringOrDoubleOrPerformanceMeasureOptions& start_or_options,
     const StringOrDouble& end,
     bool end_is_empty,
@@ -743,7 +743,7 @@ PerformanceMeasure* Performance::measureInternal(
 
 PerformanceMeasure* Performance::measureInternal(
     ScriptState* script_state,
-    const String& measure_name,
+    const AtomicString& measure_name,
     const StringOrDouble& start,
     const StringOrDouble& end,
     const ScriptValue& detail,
@@ -761,7 +761,7 @@ PerformanceMeasure* Performance::measureInternal(
   return performance_measure;
 }
 
-void Performance::clearMeasures(const String& measure_name) {
+void Performance::clearMeasures(const AtomicString& measure_name) {
   if (!user_timing_)
     user_timing_ = UserTiming::Create(*this);
   user_timing_->ClearMeasures(measure_name);

third_party/blink/renderer/core/timing/performance.h

@@ -115,7 +115,7 @@ class CORE_EXPORT Performance : public EventTargetWithInlineData {
 
   PerformanceEntryVector getEntries();
   PerformanceEntryVector getEntriesByType(const AtomicString& entry_type);
-  PerformanceEntryVector getEntriesByName(const String& name,
+  PerformanceEntryVector getEntriesByName(const AtomicString& name,
                                           const AtomicString& entry_type);
 
   void clearResourceTimings();
@@ -126,7 +126,7 @@ class CORE_EXPORT Performance : public EventTargetWithInlineData {
   void AddLongTaskTiming(
       TimeTicks start_time,
       TimeTicks end_time,
-      const String& name,
+      const AtomicString& name,
       const String& culprit_frame_src,
       const String& culprit_frame_id,
       const String& culprit_frame_name,
@@ -161,34 +161,36 @@ class CORE_EXPORT Performance : public EventTargetWithInlineData {
   void setEventTimingBufferMaxSize(unsigned);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(eventtimingbufferfull);
 
-  PerformanceMark* mark(ScriptState*, const String& mark_name, ExceptionState&);
+  PerformanceMark* mark(ScriptState*,
+                        const AtomicString& mark_name,
+                        ExceptionState&);
 
   PerformanceMark* mark(
       ScriptState*,
-      const String& mark_name,
+      const AtomicString& mark_name,
       DoubleOrPerformanceMarkOptions& start_time_or_mark_options,
       ExceptionState&);
 
-  void clearMarks(const String& mark_name);
+  void clearMarks(const AtomicString& mark_name);
 
   PerformanceMeasure* measure(ScriptState*,
-                              const String& measure_name,
+                              const AtomicString& measure_name,
                               ExceptionState&);
 
   PerformanceMeasure* measure(
       ScriptState*,
-      const String& measure_name,
+      const AtomicString& measure_name,
       const StringOrDoubleOrPerformanceMeasureOptions& start_or_options,
       ExceptionState&);
 
   PerformanceMeasure* measure(
       ScriptState*,
-      const String& measure_name,
+      const AtomicString& measure_name,
       const StringOrDoubleOrPerformanceMeasureOptions& start_or_options,
       const StringOrDouble& end,
       ExceptionState&);
 
-  void clearMeasures(const String& measure_name);
+  void clearMeasures(const AtomicString& measure_name);
 
   void UnregisterPerformanceObserver(PerformanceObserver&);
   void RegisterPerformanceObserver(PerformanceObserver&);
@@ -215,14 +217,14 @@ class CORE_EXPORT Performance : public EventTargetWithInlineData {
 
   PerformanceMeasure* measureInternal(
       ScriptState*,
-      const String& measure_name,
+      const AtomicString& measure_name,
       const StringOrDoubleOrPerformanceMeasureOptions& start,
       const StringOrDouble& end,
       bool end_is_empty,
       ExceptionState&);
 
   PerformanceMeasure* measureInternal(ScriptState*,
-                                      const String& measure_name,
+                                      const AtomicString& measure_name,
                                       const StringOrDouble& start,
                                       const StringOrDouble& end,
                                       const ScriptValue& detail,

third_party/blink/renderer/core/timing/performance_entry.cc

@@ -40,7 +40,7 @@ namespace {
 static base::AtomicSequenceNumber index_seq;
 }
 
-PerformanceEntry::PerformanceEntry(const String& name,
+PerformanceEntry::PerformanceEntry(const AtomicString& name,
                                    double start_time,
                                    double finish_time)
     : duration_(finish_time - start_time),
@@ -50,10 +50,6 @@ PerformanceEntry::PerformanceEntry(const String& name,
 
 PerformanceEntry::~PerformanceEntry() = default;
 
-String PerformanceEntry::name() const {
-  return name_;
-}
-
 DOMHighResTimeStamp PerformanceEntry::startTime() const {
   return start_time_;
 }

third_party/blink/renderer/core/timing/performance_entry.h

@@ -68,7 +68,7 @@ class CORE_EXPORT PerformanceEntry : public ScriptWrappable {
     kFirstInput = 1 << 10,
   };
 
-  String name() const;
+  const AtomicString& name() const { return name_; }
   DOMHighResTimeStamp startTime() const;
   virtual AtomicString entryType() const = 0;
   virtual PerformanceEntryType EntryTypeEnum() const = 0;
@@ -108,7 +108,7 @@ class CORE_EXPORT PerformanceEntry : public ScriptWrappable {
       const AtomicString& entry_type);
 
  protected:
-  PerformanceEntry(const String& name,
+  PerformanceEntry(const AtomicString& name,
                    double start_time,
                    double finish_time);
   virtual void BuildJSONValue(V8ObjectBuilder&) const;
@@ -117,7 +117,7 @@ class CORE_EXPORT PerformanceEntry : public ScriptWrappable {
   double duration_;
 
  private:
-  const String name_;
+  const AtomicString name_;
   const double start_time_;
   const int index_;
 };

third_party/blink/renderer/core/timing/performance_event_timing.cc

@@ -10,7 +10,7 @@ namespace blink {
 
 // static
 PerformanceEventTiming* PerformanceEventTiming::Create(
-    const String& event_type,
+    const AtomicString& event_type,
     DOMHighResTimeStamp start_time,
     DOMHighResTimeStamp processing_start,
     DOMHighResTimeStamp processing_end,
@@ -34,7 +34,7 @@ PerformanceEventTiming* PerformanceEventTiming::CreateFirstInputTiming(
 }
 
 PerformanceEventTiming::PerformanceEventTiming(
-    const String& event_type,
+    const AtomicString& event_type,
     const AtomicString& entry_type,
     DOMHighResTimeStamp start_time,
     DOMHighResTimeStamp processing_start,

third_party/blink/renderer/core/timing/performance_event_timing.h

@@ -16,7 +16,7 @@ class CORE_EXPORT PerformanceEventTiming final : public PerformanceEntry {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static PerformanceEventTiming* Create(const String& event_type,
+  static PerformanceEventTiming* Create(const AtomicString& event_type,
                                         DOMHighResTimeStamp start_time,
                                         DOMHighResTimeStamp processing_start,
                                         DOMHighResTimeStamp processing_end,
@@ -42,7 +42,7 @@ class CORE_EXPORT PerformanceEventTiming final : public PerformanceEntry {
   void Trace(blink::Visitor*) override;
 
  private:
-  PerformanceEventTiming(const String& event_type,
+  PerformanceEventTiming(const AtomicString& event_type,
                          const AtomicString& entry_type,
                          DOMHighResTimeStamp start_time,
                          DOMHighResTimeStamp processing_start,

third_party/blink/renderer/core/timing/performance_long_task_timing.cc

@@ -16,10 +16,10 @@ namespace blink {
 PerformanceLongTaskTiming* PerformanceLongTaskTiming::Create(
     double start_time,
     double end_time,
-    String name,
-    String frame_src,
-    String frame_id,
-    String frame_name,
+    const AtomicString& name,
+    const String& frame_src,
+    const String& frame_id,
+    const String& frame_name,
     const SubTaskAttribution::EntriesVector& sub_task_attributions) {
   return new PerformanceLongTaskTiming(start_time, end_time, name, frame_src,
                                        frame_id, frame_name,
@@ -29,10 +29,10 @@ PerformanceLongTaskTiming* PerformanceLongTaskTiming::Create(
 PerformanceLongTaskTiming::PerformanceLongTaskTiming(
     double start_time,
     double end_time,
-    String name,
-    String culprit_frame_src,
-    String culprit_frame_id,
-    String culprit_frame_name,
+    const AtomicString& name,
+    const String& culprit_frame_src,
+    const String& culprit_frame_id,
+    const String& culprit_frame_name,
     const SubTaskAttribution::EntriesVector& sub_task_attributions)
     : PerformanceEntry(name, start_time, end_time) {
   // Only one possible container type exists currently: "iframe".

third_party/blink/renderer/core/timing/performance_long_task_timing.h

@@ -23,10 +23,10 @@ class PerformanceLongTaskTiming final : public PerformanceEntry {
   static PerformanceLongTaskTiming* Create(
       double start_time,
       double end_time,
-      String name,
-      String frame_src,
-      String frame_id,
-      String frame_name,
+      const AtomicString& name,
+      const String& frame_src,
+      const String& frame_id,
+      const String& frame_name,
       const SubTaskAttribution::EntriesVector& sub_task_attributions);
 
   AtomicString entryType() const override;
@@ -40,10 +40,10 @@ class PerformanceLongTaskTiming final : public PerformanceEntry {
   PerformanceLongTaskTiming(
       double start_time,
       double end_time,
-      String name,
-      String frame_src,
-      String frame_id,
-      String frame_name,
+      const AtomicString& name,
+      const String& frame_src,
+      const String& frame_id,
+      const String& frame_name,
       const SubTaskAttribution::EntriesVector& sub_task_attributions);
   ~PerformanceLongTaskTiming() override;
 

third_party/blink/renderer/core/timing/performance_mark.cc

@@ -10,7 +10,7 @@
 namespace blink {
 
 PerformanceMark::PerformanceMark(ScriptState* script_state,
-                                 const String& name,
+                                 const AtomicString& name,
                                  double start_time,
                                  const ScriptValue& detail)
     : PerformanceEntry(name, start_time, start_time) {

third_party/blink/renderer/core/timing/performance_mark.h

@@ -38,7 +38,7 @@ class CORE_EXPORT PerformanceMark final : public PerformanceEntry {
 
  public:
   static PerformanceMark* Create(ScriptState* script_state,
-                                 const String& name,
+                                 const AtomicString& name,
                                  double start_time,
                                  const ScriptValue& detail) {
     return new PerformanceMark(script_state, name, start_time, detail);
@@ -53,7 +53,7 @@ class CORE_EXPORT PerformanceMark final : public PerformanceEntry {
 
  private:
   PerformanceMark(ScriptState*,
-                  const String& name,
+                  const AtomicString& name,
                   double start_time,
                   const ScriptValue& detail);
 

third_party/blink/renderer/core/timing/performance_measure.cc

@@ -10,7 +10,7 @@
 namespace blink {
 
 PerformanceMeasure::PerformanceMeasure(ScriptState* script_state,
-                                       const String& name,
+                                       const AtomicString& name,
                                        double start_time,
                                        double end_time,
                                        const ScriptValue& detail)

third_party/blink/renderer/core/timing/performance_measure.h

@@ -39,7 +39,7 @@ class PerformanceMeasure final : public PerformanceEntry {
 
  public:
   static PerformanceMeasure* Create(ScriptState* script_state,
-                                    const String& name,
+                                    const AtomicString& name,
                                     double start_time,
                                     double end_time,
                                     const ScriptValue& detail) {
@@ -57,7 +57,7 @@ class PerformanceMeasure final : public PerformanceEntry {
 
  private:
   PerformanceMeasure(ScriptState*,
-                     const String& name,
+                     const AtomicString& name,
                      double start_time,
                      double end_time,
                      const ScriptValue& detail);

third_party/blink/renderer/core/timing/performance_navigation_timing.cc

@@ -22,7 +22,8 @@ PerformanceNavigationTiming::PerformanceNavigationTiming(
     TimeTicks time_origin,
     const WebVector<WebServerTimingInfo>& server_timing)
     : PerformanceResourceTiming(
-          info ? info->FinalResponse().Url().GetString() : "",
+          info ? AtomicString(info->FinalResponse().Url().GetString())
+               : g_empty_atom,
           time_origin,
           server_timing),
       ContextClient(frame),

third_party/blink/renderer/core/timing/performance_paint_timing.cc

@@ -8,6 +8,27 @@
 
 namespace blink {
 
+namespace {
+
+AtomicString FromPaintTypeToString(PerformancePaintTiming::PaintType type) {
+  DCHECK(IsMainThread());
+  switch (type) {
+    case PerformancePaintTiming::PaintType::kFirstPaint: {
+      DEFINE_STATIC_LOCAL(const AtomicString, kFirstPaint, ("first-paint"));
+      return kFirstPaint;
+    }
+    case PerformancePaintTiming::PaintType::kFirstContentfulPaint: {
+      DEFINE_STATIC_LOCAL(const AtomicString, kFirstContentfulPaint,
+                          ("first-contentful-paint"));
+      return kFirstContentfulPaint;
+    }
+  }
+  NOTREACHED();
+  return g_empty_atom;
+}
+
+}  // namespace
+
 PerformancePaintTiming::PerformancePaintTiming(PaintType type,
                                                double start_time)
     : PerformanceEntry(FromPaintTypeToString(type),
@@ -24,14 +45,4 @@ PerformanceEntryType PerformancePaintTiming::EntryTypeEnum() const {
   return PerformanceEntry::EntryType::kPaint;
 }
 
-String PerformancePaintTiming::FromPaintTypeToString(PaintType type) {
-  switch (type) {
-    case PaintType::kFirstPaint:
-      return "first-paint";
-    case PaintType::kFirstContentfulPaint:
-      return "first-contentful-paint";
-  }
-  NOTREACHED();
-  return "";
-}
 }  // namespace blink

third_party/blink/renderer/core/timing/performance_paint_timing.h

@@ -21,9 +21,8 @@ class CORE_EXPORT PerformancePaintTiming final : public PerformanceEntry {
 
   AtomicString entryType() const override;
   PerformanceEntryType EntryTypeEnum() const override;
-
-  static String FromPaintTypeToString(PaintType);
 };
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_PAINT_TIMING_H_

third_party/blink/renderer/core/timing/performance_resource_timing.cc

@@ -76,7 +76,7 @@ PerformanceResourceTiming::PerformanceResourceTiming(
 
 // This constructor is for PerformanceNavigationTiming.
 PerformanceResourceTiming::PerformanceResourceTiming(
-    const String& name,
+    const AtomicString& name,
     TimeTicks time_origin,
     const WebVector<WebServerTimingInfo>& server_timing)
     : PerformanceEntry(name, 0.0, 0.0),

third_party/blink/renderer/core/timing/performance_resource_timing.h

@@ -87,7 +87,7 @@ class CORE_EXPORT PerformanceResourceTiming : public PerformanceEntry {
 
   // This constructor is for PerformanceNavigationTiming.
   // Related doc: https://goo.gl/uNecAj.
-  PerformanceResourceTiming(const String& name,
+  PerformanceResourceTiming(const AtomicString& name,
                             TimeTicks time_origin,
                             const WebVector<WebServerTimingInfo>&);
   virtual AtomicString AlpnNegotiatedProtocol() const;

third_party/blink/renderer/core/timing/performance_user_timing.cc

@@ -38,37 +38,38 @@ namespace blink {
 
 namespace {
 
-using RestrictedKeyMap = HashMap<String, NavigationTimingFunction>;
+using RestrictedKeyMap = HashMap<AtomicString, NavigationTimingFunction>;
 
 const RestrictedKeyMap& GetRestrictedKeyMap() {
-  DEFINE_THREAD_SAFE_STATIC_LOCAL(
-      RestrictedKeyMap, map,
-      ({
-          {"navigationStart", &PerformanceTiming::navigationStart},
-          {"unloadEventStart", &PerformanceTiming::unloadEventStart},
-          {"unloadEventEnd", &PerformanceTiming::unloadEventEnd},
-          {"redirectStart", &PerformanceTiming::redirectStart},
-          {"redirectEnd", &PerformanceTiming::redirectEnd},
-          {"fetchStart", &PerformanceTiming::fetchStart},
-          {"domainLookupStart", &PerformanceTiming::domainLookupStart},
-          {"domainLookupEnd", &PerformanceTiming::domainLookupEnd},
-          {"connectStart", &PerformanceTiming::connectStart},
-          {"connectEnd", &PerformanceTiming::connectEnd},
-          {"secureConnectionStart", &PerformanceTiming::secureConnectionStart},
-          {"requestStart", &PerformanceTiming::requestStart},
-          {"responseStart", &PerformanceTiming::responseStart},
-          {"responseEnd", &PerformanceTiming::responseEnd},
-          {"domLoading", &PerformanceTiming::domLoading},
-          {"domInteractive", &PerformanceTiming::domInteractive},
-          {"domContentLoadedEventStart",
-           &PerformanceTiming::domContentLoadedEventStart},
-          {"domContentLoadedEventEnd",
-           &PerformanceTiming::domContentLoadedEventEnd},
-          {"domComplete", &PerformanceTiming::domComplete},
-          {"loadEventStart", &PerformanceTiming::loadEventStart},
-          {"loadEventEnd", &PerformanceTiming::loadEventEnd},
-      }));
-  return map;
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<RestrictedKeyMap>, map, ());
+  if (!map.IsSet()) {
+    *map = {
+        {"navigationStart", &PerformanceTiming::navigationStart},
+        {"unloadEventStart", &PerformanceTiming::unloadEventStart},
+        {"unloadEventEnd", &PerformanceTiming::unloadEventEnd},
+        {"redirectStart", &PerformanceTiming::redirectStart},
+        {"redirectEnd", &PerformanceTiming::redirectEnd},
+        {"fetchStart", &PerformanceTiming::fetchStart},
+        {"domainLookupStart", &PerformanceTiming::domainLookupStart},
+        {"domainLookupEnd", &PerformanceTiming::domainLookupEnd},
+        {"connectStart", &PerformanceTiming::connectStart},
+        {"connectEnd", &PerformanceTiming::connectEnd},
+        {"secureConnectionStart", &PerformanceTiming::secureConnectionStart},
+        {"requestStart", &PerformanceTiming::requestStart},
+        {"responseStart", &PerformanceTiming::responseStart},
+        {"responseEnd", &PerformanceTiming::responseEnd},
+        {"domLoading", &PerformanceTiming::domLoading},
+        {"domInteractive", &PerformanceTiming::domInteractive},
+        {"domContentLoadedEventStart",
+         &PerformanceTiming::domContentLoadedEventStart},
+        {"domContentLoadedEventEnd",
+         &PerformanceTiming::domContentLoadedEventEnd},
+        {"domComplete", &PerformanceTiming::domComplete},
+        {"loadEventStart", &PerformanceTiming::loadEventStart},
+        {"loadEventEnd", &PerformanceTiming::loadEventEnd},
+    };
+  }
+  return *map;
 }
 
 }  // namespace
@@ -88,7 +89,7 @@ static void InsertPerformanceEntry(PerformanceEntryMap& performance_entry_map,
 }
 
 static void ClearPeformanceEntries(PerformanceEntryMap& performance_entry_map,
-                                   const String& name) {
+                                   const AtomicString& name) {
   if (name.IsNull()) {
     performance_entry_map.clear();
     return;
@@ -99,7 +100,7 @@ static void ClearPeformanceEntries(PerformanceEntryMap& performance_entry_map,
 }
 
 PerformanceMark* UserTiming::Mark(ScriptState* script_state,
-                                  const String& mark_name,
+                                  const AtomicString& mark_name,
                                   const DOMHighResTimeStamp& start_time,
                                   const ScriptValue& detail,
                                   ExceptionState& exception_state) {
@@ -123,11 +124,11 @@ PerformanceMark* UserTiming::Mark(ScriptState* script_state,
   return mark;
 }
 
-void UserTiming::ClearMarks(const String& mark_name) {
+void UserTiming::ClearMarks(const AtomicString& mark_name) {
   ClearPeformanceEntries(marks_map_, mark_name);
 }
 
-double UserTiming::FindExistingMarkStartTime(const String& mark_name,
+double UserTiming::FindExistingMarkStartTime(const AtomicString& mark_name,
                                              ExceptionState& exception_state) {
   if (marks_map_.Contains(mark_name))
     return marks_map_.at(mark_name).back()->startTime();
@@ -155,8 +156,10 @@ double UserTiming::FindExistingMarkStartTime(const String& mark_name,
 
 double UserTiming::FindStartMarkOrTime(const StringOrDouble& start,
                                        ExceptionState& exception_state) {
-  if (start.IsString())
-    return FindExistingMarkStartTime(start.GetAsString(), exception_state);
+  if (start.IsString()) {
+    return FindExistingMarkStartTime(AtomicString(start.GetAsString()),
+                                     exception_state);
+  }
   if (start.IsDouble())
     return start.GetAsDouble();
   NOTREACHED();
@@ -164,7 +167,7 @@ double UserTiming::FindStartMarkOrTime(const StringOrDouble& start,
 }
 
 PerformanceMeasure* UserTiming::Measure(ScriptState* script_state,
-                                        const String& measure_name,
+                                        const AtomicString& measure_name,
                                         const StringOrDouble& start,
                                         const StringOrDouble& end,
                                         const ScriptValue& detail,
@@ -216,7 +219,7 @@ PerformanceMeasure* UserTiming::Measure(ScriptState* script_state,
   return measure;
 }
 
-void UserTiming::ClearMeasures(const String& measure_name) {
+void UserTiming::ClearMeasures(const AtomicString& measure_name) {
   ClearPeformanceEntries(measures_map_, measure_name);
 }
 
@@ -232,7 +235,7 @@ static PerformanceEntryVector ConvertToEntrySequence(
 
 static PerformanceEntryVector GetEntrySequenceByName(
     const PerformanceEntryMap& performance_entry_map,
-    const String& name) {
+    const AtomicString& name) {
   PerformanceEntryVector entries;
 
   PerformanceEntryMap::const_iterator it = performance_entry_map.find(name);
@@ -246,7 +249,7 @@ PerformanceEntryVector UserTiming::GetMarks() const {
   return ConvertToEntrySequence(marks_map_);
 }
 
-PerformanceEntryVector UserTiming::GetMarks(const String& name) const {
+PerformanceEntryVector UserTiming::GetMarks(const AtomicString& name) const {
   return GetEntrySequenceByName(marks_map_, name);
 }
 
@@ -254,7 +257,7 @@ PerformanceEntryVector UserTiming::GetMeasures() const {
   return ConvertToEntrySequence(measures_map_);
 }
 
-PerformanceEntryVector UserTiming::GetMeasures(const String& name) const {
+PerformanceEntryVector UserTiming::GetMeasures(const AtomicString& name) const {
   return GetEntrySequenceByName(measures_map_, name);
 }
 

third_party/blink/renderer/core/timing/performance_user_timing.h

@@ -39,7 +39,7 @@ class Performance;
 
 typedef unsigned long long (
     PerformanceTiming::*NavigationTimingFunction)() const;
-using PerformanceEntryMap = HeapHashMap<String, PerformanceEntryVector>;
+using PerformanceEntryMap = HeapHashMap<AtomicString, PerformanceEntryVector>;
 
 class UserTiming final : public GarbageCollected<UserTiming> {
  public:
@@ -48,32 +48,33 @@ class UserTiming final : public GarbageCollected<UserTiming> {
   }
 
   PerformanceMark* Mark(ScriptState*,
-                        const String& mark_name,
+                        const AtomicString& mark_name,
                         const DOMHighResTimeStamp& start_time,
                         const ScriptValue& detail,
                         ExceptionState&);
-  void ClearMarks(const String& mark_name);
+  void ClearMarks(const AtomicString& mark_name);
 
   PerformanceMeasure* Measure(ScriptState*,
-                              const String& measure_name,
+                              const AtomicString& measure_name,
                               const StringOrDouble& start,
                               const StringOrDouble& end,
                               const ScriptValue& detail,
                               ExceptionState&);
-  void ClearMeasures(const String& measure_name);
+  void ClearMeasures(const AtomicString& measure_name);
 
   PerformanceEntryVector GetMarks() const;
   PerformanceEntryVector GetMeasures() const;
 
-  PerformanceEntryVector GetMarks(const String& name) const;
-  PerformanceEntryVector GetMeasures(const String& name) const;
+  PerformanceEntryVector GetMarks(const AtomicString& name) const;
+  PerformanceEntryVector GetMeasures(const AtomicString& name) const;
 
   void Trace(blink::Visitor*);
 
  private:
   explicit UserTiming(Performance&);
 
-  double FindExistingMarkStartTime(const String& mark_name, ExceptionState&);
+  double FindExistingMarkStartTime(const AtomicString& mark_name,
+                                   ExceptionState&);
   double FindStartMarkOrTime(const StringOrDouble& start, ExceptionState&);
 
   Member<Performance> performance_;

third_party/blink/renderer/core/timing/sub_task_attribution.cc

@@ -6,8 +6,8 @@
 
 namespace blink {
 
-SubTaskAttribution::SubTaskAttribution(String sub_task_name,
-                                       String script_url,
+SubTaskAttribution::SubTaskAttribution(const AtomicString& sub_task_name,
+                                       const String& script_url,
                                        TimeTicks start_time,
                                        TimeDelta duration)
     : sub_task_name_(sub_task_name),

third_party/blink/renderer/core/timing/sub_task_attribution.h

@@ -18,18 +18,19 @@ class SubTaskAttribution {
  public:
   using EntriesVector = Vector<std::unique_ptr<SubTaskAttribution>>;
 
-  static std::unique_ptr<SubTaskAttribution> Create(String sub_task_name,
-                                                    String script_url,
-                                                    TimeTicks start_time,
-                                                    TimeDelta duration) {
+  static std::unique_ptr<SubTaskAttribution> Create(
+      const AtomicString& sub_task_name,
+      const String& script_url,
+      TimeTicks start_time,
+      TimeDelta duration) {
     return std::make_unique<SubTaskAttribution>(sub_task_name, script_url,
                                                 start_time, duration);
   }
-  SubTaskAttribution(String sub_task_name,
-                     String script_url,
+  SubTaskAttribution(const AtomicString& sub_task_name,
+                     const String& script_url,
                      TimeTicks start_time,
                      TimeDelta duration);
-  inline String subTaskName() const { return sub_task_name_; }
+  inline AtomicString subTaskName() const { return sub_task_name_; }
   inline String scriptURL() const { return script_url_; }
   inline TimeTicks startTime() const { return start_time_; }
   inline TimeDelta duration() const { return duration_; }
@@ -48,7 +49,7 @@ class SubTaskAttribution {
   }
 
  private:
-  String sub_task_name_;
+  AtomicString sub_task_name_;
   String script_url_;
   TimeTicks start_time_;
   TimeDelta duration_;

third_party/blink/renderer/core/timing/task_attribution_timing.cc

@@ -9,14 +9,14 @@
 
 namespace blink {
 
-TaskAttributionTiming::TaskAttributionTiming(String name,
-                                             String container_type,
-                                             String container_src,
-                                             String container_id,
-                                             String container_name,
+TaskAttributionTiming::TaskAttributionTiming(const AtomicString& name,
+                                             const String& container_type,
+                                             const String& container_src,
+                                             const String& container_id,
+                                             const String& container_name,
                                              double start_time,
                                              double finish_time,
-                                             String script_url)
+                                             const String& script_url)
     : PerformanceEntry(name, start_time, finish_time),
       container_type_(container_type),
       container_src_(container_src),

third_party/blink/renderer/core/timing/task_attribution_timing.h

@@ -17,25 +17,25 @@ class TaskAttributionTiming final : public PerformanceEntry {
 
  public:
   // Used when the LongTaskV2 flag is enabled.
-  static TaskAttributionTiming* Create(String type,
-                                       String container_type,
-                                       String container_src,
-                                       String container_id,
-                                       String container_name,
+  static TaskAttributionTiming* Create(const AtomicString& type,
+                                       const String& container_type,
+                                       const String& container_src,
+                                       const String& container_id,
+                                       const String& container_name,
                                        double start_time,
                                        double finish_time,
-                                       String script_url) {
+                                       const String& script_url) {
     return new TaskAttributionTiming(type, container_type, container_src,
                                      container_id, container_name, start_time,
                                      finish_time, script_url);
   }
 
   // Used when the LongTaskV2 flag is disabled.
-  static TaskAttributionTiming* Create(String type,
-                                       String container_type,
-                                       String container_src,
-                                       String container_id,
-                                       String container_name) {
+  static TaskAttributionTiming* Create(const AtomicString& type,
+                                       const String& container_type,
+                                       const String& container_src,
+                                       const String& container_id,
+                                       const String& container_name) {
     return new TaskAttributionTiming(type, container_type, container_src,
                                      container_id, container_name, 0.0, 0.0,
                                      g_empty_string);
@@ -55,14 +55,14 @@ class TaskAttributionTiming final : public PerformanceEntry {
   ~TaskAttributionTiming() override;
 
  private:
-  TaskAttributionTiming(String type,
-                        String container_type,
-                        String container_src,
-                        String container_id,
-                        String container_name,
+  TaskAttributionTiming(const AtomicString& type,
+                        const String& container_type,
+                        const String& container_src,
+                        const String& container_id,
+                        const String& container_name,
                         double start_time,
                         double finish_time,
-                        String script_url);
+                        const String& script_url);
   void BuildJSONValue(V8ObjectBuilder&) const override;
 
   String container_type_;

third_party/blink/renderer/core/timing/window_performance.cc

@@ -55,17 +55,6 @@
 static constexpr base::TimeDelta kLongTaskObserverThreshold =
     base::TimeDelta::FromMilliseconds(50);
 
-static const char kUnknownAttribution[] = "unknown";
-static const char kAmbiguousAttribution[] = "multiple-contexts";
-static const char kSameOriginAttribution[] = "same-origin";
-static const char kSameOriginSelfAttribution[] = "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 {
@@ -87,21 +76,45 @@ String GetFrameAttribute(HTMLFrameOwnerElement* frame_owner,
   return attr_value;
 }
 
-const char* SameOriginAttribution(Frame* observer_frame, Frame* culprit_frame) {
+const AtomicString& SelfKeyword() {
+  DEFINE_STATIC_LOCAL(const AtomicString, kSelfAttribution, ("self"));
+  return kSelfAttribution;
+}
+
+const AtomicString& SameOriginAncestorKeyword() {
+  DEFINE_STATIC_LOCAL(const AtomicString, kSameOriginAncestorAttribution,
+                      ("same-origin-ancestor"));
+  return kSameOriginAncestorAttribution;
+}
+
+const AtomicString& SameOriginDescendantKeyword() {
+  DEFINE_STATIC_LOCAL(const AtomicString, kSameOriginDescendantAttribution,
+                      ("same-origin-descendant"));
+  return kSameOriginDescendantAttribution;
+}
+
+const AtomicString& SameOriginKeyword() {
+  DEFINE_STATIC_LOCAL(const AtomicString, kSameOriginAttribution,
+                      ("same-origin"));
+  return kSameOriginAttribution;
+}
+
+AtomicString SameOriginAttribution(Frame* observer_frame,
+                                   Frame* culprit_frame) {
+  DCHECK(IsMainThread());
   if (observer_frame == culprit_frame)
-    return kSameOriginSelfAttribution;
+    return SelfKeyword();
   if (observer_frame->Tree().IsDescendantOf(culprit_frame))
-    return kSameOriginAncestorAttribution;
+    return SameOriginAncestorKeyword();
   if (culprit_frame->Tree().IsDescendantOf(observer_frame))
-    return kSameOriginDescendantAttribution;
-  return kSameOriginAttribution;
+    return SameOriginDescendantKeyword();
+  return SameOriginKeyword();
 }
 
-bool IsSameOrigin(String key) {
-  return key == kSameOriginAttribution ||
-         key == kSameOriginDescendantAttribution ||
-         key == kSameOriginAncestorAttribution ||
-         key == kSameOriginSelfAttribution;
+bool IsSameOrigin(const AtomicString& key) {
+  DCHECK(IsMainThread());
+  return key == SameOriginKeyword() || key == SameOriginDescendantKeyword() ||
+         key == SameOriginAncestorKeyword() || key == SelfKeyword();
 }
 
 }  // namespace
@@ -228,18 +241,22 @@ static bool CanAccessOrigin(Frame* frame1, Frame* frame2) {
  * See detailed Security doc here: http://bit.ly/2duD3F7
  */
 // static
-std::pair<String, DOMWindow*> WindowPerformance::SanitizedAttribution(
+std::pair<AtomicString, DOMWindow*> WindowPerformance::SanitizedAttribution(
     ExecutionContext* task_context,
     bool has_multiple_contexts,
     LocalFrame* observer_frame) {
+  DCHECK(IsMainThread());
   if (has_multiple_contexts) {
     // Unable to attribute, multiple script execution contents were involved.
+    DEFINE_STATIC_LOCAL(const AtomicString, kAmbiguousAttribution,
+                        ("multiple-contexts"));
     return std::make_pair(kAmbiguousAttribution, nullptr);
   }
 
   if (!task_context || !task_context->IsDocument() ||
       !ToDocument(task_context)->GetFrame()) {
     // Unable to attribute as no script was involved.
+    DEFINE_STATIC_LOCAL(const AtomicString, kUnknownAttribution, ("unknown"));
     return std::make_pair(kUnknownAttribution, nullptr);
   }
 
@@ -266,12 +283,18 @@ std::pair<String, DOMWindow*> WindowPerformance::SanitizedAttribution(
         last_cross_origin_frame = frame;
       }
     }
+    DEFINE_STATIC_LOCAL(const AtomicString, kCrossOriginDescendantAttribution,
+                        ("cross-origin-descendant"));
     return std::make_pair(kCrossOriginDescendantAttribution,
                           last_cross_origin_frame->DomWindow());
   }
   if (observer_frame->Tree().IsDescendantOf(culprit_frame)) {
+    DEFINE_STATIC_LOCAL(const AtomicString, kCrossOriginAncestorAttribution,
+                        ("cross-origin-ancestor"));
     return std::make_pair(kCrossOriginAncestorAttribution, nullptr);
   }
+  DEFINE_STATIC_LOCAL(const AtomicString, kCrossOriginAttribution,
+                      ("cross-origin-unreachable"));
   return std::make_pair(kCrossOriginAttribution, nullptr);
 }
 
@@ -283,7 +306,7 @@ void WindowPerformance::ReportLongTask(
     const SubTaskAttribution::EntriesVector& sub_task_attributions) {
   if (!GetFrame())
     return;
-  std::pair<String, DOMWindow*> attribution =
+  std::pair<AtomicString, DOMWindow*> attribution =
       WindowPerformance::SanitizedAttribution(
           task_context, has_multiple_contexts, GetFrame());
   DOMWindow* culprit_dom_window = attribution.second;
@@ -316,7 +339,7 @@ bool WindowPerformance::ObservingEventTimingEntries() {
   return HasObserverFor(PerformanceEntry::kEvent);
 }
 
-void WindowPerformance::RegisterEventTiming(String event_type,
+void WindowPerformance::RegisterEventTiming(const AtomicString& event_type,
                                             TimeTicks start_time,
                                             TimeTicks processing_start,
                                             TimeTicks processing_end,

third_party/blink/renderer/core/timing/window_performance.h

@@ -73,7 +73,7 @@ class CORE_EXPORT WindowPerformance final : public Performance,
   // This method creates a PerformanceEventTiming and if needed creates a swap
   // promise to calculate the |duration| attribute when such promise is
   // resolved.
-  void RegisterEventTiming(String event_type,
+  void RegisterEventTiming(const AtomicString& event_type,
                            TimeTicks start_time,
                            TimeTicks processing_start,
                            TimeTicks processing_end,
@@ -86,7 +86,7 @@ class CORE_EXPORT WindowPerformance final : public Performance,
 
   PerformanceNavigationTiming* CreateNavigationTimingInstance() override;
 
-  static std::pair<String, DOMWindow*> SanitizedAttribution(
+  static std::pair<AtomicString, DOMWindow*> SanitizedAttribution(
       ExecutionContext*,
       bool has_multiple_contexts,
       LocalFrame* observer_frame);

third_party/blink/renderer/core/timing/window_performance_test.cc

@@ -198,22 +198,22 @@ TEST_F(WindowPerformanceTest, EnsureEntryListOrder) {
   DummyExceptionStateForTesting exception_state;
   clock.Advance(TimeDelta::FromSeconds(2));
   for (int i = 0; i < 8; i++) {
-    performance_->mark(scope.GetScriptState(), String::Number(i),
+    performance_->mark(scope.GetScriptState(), AtomicString::Number(i),
                        exception_state);
   }
   clock.Advance(TimeDelta::FromSeconds(2));
   for (int i = 8; i < 17; i++) {
-    performance_->mark(scope.GetScriptState(), String::Number(i),
+    performance_->mark(scope.GetScriptState(), AtomicString::Number(i),
                        exception_state);
   }
   PerformanceEntryVector entries = performance_->getEntries();
   EXPECT_EQ(17U, entries.size());
   for (int i = 0; i < 8; i++) {
-    EXPECT_EQ(String::Number(i), entries[i]->name());
+    EXPECT_EQ(AtomicString::Number(i), entries[i]->name());
     EXPECT_NEAR(2000, entries[i]->startTime(), 0.005);
   }
   for (int i = 8; i < 17; i++) {
-    EXPECT_EQ(String::Number(i), entries[i]->name());
+    EXPECT_EQ(AtomicString::Number(i), entries[i]->name());
     EXPECT_NEAR(4000, entries[i]->startTime(), 0.005);
   }
 }
@@ -305,7 +305,7 @@ TEST_F(WindowPerformanceTest, MultipleEventsSameSwap) {
 // Test for existence of 'firstInput' given different types of first events.
 TEST_F(WindowPerformanceTest, FirstInput) {
   struct {
-    String event_type;
+    AtomicString event_type;
     bool should_report;
   } inputs[] = {{"click", true},     {"keydown", true},
                 {"keypress", false}, {"pointerdown", false},
@@ -329,7 +329,7 @@ TEST_F(WindowPerformanceTest, FirstInput) {
 // Test that the 'firstInput' is populated after some irrelevant events are
 // ignored.
 TEST_F(WindowPerformanceTest, FirstInputAfterIgnored) {
-  String several_events[] = {"mousemove", "mouseover", "mousedown"};
+  AtomicString several_events[] = {"mousemove", "mouseover", "mousedown"};
   for (const auto& event : several_events) {
     performance_->RegisterEventTiming(
         event, GetTimeOrigin(),