Add histogram for Blink's spell check request interval

third_party/WebKit/Source/core/editing/spellcheck/SpellCheckRequester.cpp

 /*
  * Copyright (C) 2010 Google 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 16 matching lines @@
 
 #include "core/dom/Document.h"
 #include "core/dom/Node.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/spellcheck/SpellChecker.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/TextControlElement.h"
+#include "platform/Histogram.h"
 #include "platform/text/TextCheckerClient.h"
 
 namespace blink {
 
 SpellCheckRequest::SpellCheckRequest(Range* checking_range,
                                      const String& text,
                                      int request_number)
     : requester_(nullptr),
       checking_range_(checking_range),
       root_editable_element_(
@@ skipping 71 matching lines @@
   DCHECK(!requester_);
   DCHECK_EQ(request_data_.Sequence(), kUnrequestedTextCheckingSequence);
   requester_ = requester;
   request_data_.SetSequence(sequence);
 }
 
 SpellCheckRequester::SpellCheckRequester(LocalFrame& frame)
     : frame_(&frame),
       last_request_sequence_(0),
       last_processed_sequence_(0),
+      last_request_time_(0.0),
       timer_to_process_queued_request_(
           TaskRunnerHelper::Get(TaskType::kUnspecedTimer, &frame),
           this,
           &SpellCheckRequester::TimerFiredToProcessQueuedRequest) {}
 
 SpellCheckRequester::~SpellCheckRequester() {}
 
 TextCheckerClient& SpellCheckRequester::Client() const {
   return GetFrame().GetSpellChecker().TextChecker();
 }
 
 void SpellCheckRequester::TimerFiredToProcessQueuedRequest(TimerBase*) {
   DCHECK(!request_queue_.IsEmpty());
   if (request_queue_.IsEmpty())
     return;
 
   InvokeRequest(request_queue_.TakeFirst());
 }
 
 void SpellCheckRequester::RequestCheckingFor(const EphemeralRange& range) {
   RequestCheckingFor(range, 0);
 }
 
 void SpellCheckRequester::RequestCheckingFor(const EphemeralRange& range,
                                              int request_num) {
   SpellCheckRequest* request = SpellCheckRequest::Create(range, request_num);
   if (!request)
     return;
 
+  DEFINE_STATIC_LOCAL(CustomCountHistogram,
+                      spell_checker_request_interval_histogram,
+                      ("WebCore.SpellChecker.RequestInterval", 0, 10000, 50));
+  const double current_request_time = MonotonicallyIncreasingTime();
+  if (request_num == 0 && last_request_time_ > 0) {
+    const double interval_ms =
+        (current_request_time - last_request_time_) * 1000.0;
+    spell_checker_request_interval_histogram.Count(interval_ms);
+  }
+  last_request_time_ = current_request_time;
+
   DCHECK_EQ(request->Data().Sequence(), kUnrequestedTextCheckingSequence);
   int sequence = ++last_request_sequence_;
   if (sequence == kUnrequestedTextCheckingSequence)
     sequence = ++last_request_sequence_;
 
   request->SetCheckerAndSequence(this, sequence);
 
   if (timer_to_process_queued_request_.IsActive() || processing_request_) {
     EnqueueRequest(request);
     return;
@@ skipping 110 matching lines @@
   DidCheck(sequence, results);
 }
 
 DEFINE_TRACE(SpellCheckRequester) {
   visitor->Trace(frame_);
   visitor->Trace(processing_request_);
   visitor->Trace(request_queue_);
 }
 
 }  // namespace blink