Move and rename TaskTimeTracker to public interface exposed to WebThread, use in WebPerf Agent.

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/task_queue_selector.h"
-#include "platform/scheduler/base/task_time_tracker.h"
 #include "platform/scheduler/base/work_queue.h"
 #include "platform/scheduler/base/work_queue_sets.h"
+#include "public/platform/scheduler/base/task_time_tracker.h"
 
 namespace blink {
 namespace scheduler {
 
 namespace {
 const size_t kRecordRecordTaskDelayHistogramsEveryNTasks = 10;
 
 void RecordDelayedTaskLateness(base::TimeDelta lateness) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.TaskQueueManager.DelayedTaskLateness",
                       lateness);
 }
 
 void RecordImmediateTaskQueueingDuration(tracked_objects::Duration duration) {
   UMA_HISTOGRAM_TIMES(
       "RendererScheduler.TaskQueueManager.ImmediateTaskQueueingDuration",
       base::TimeDelta::FromMilliseconds(duration.InMilliseconds()));
 }
+
+double MonotonicTimeInSeconds(base::TimeTicks timeTicks) {
+  return (timeTicks.ToInternalValue() /

[alph, 2016/08/22 23:51:07]

nit: (timeTicks - base::TimeTicks()).InSecondsF()

[panicker, 2016/08/25 23:11:52]

Done.

+          static_cast<double>(base::Time::kMicrosecondsPerSecond));
+}
 }
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<TaskQueueManagerDelegate> delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : real_time_domain_(new RealTimeDomain(tracing_category)),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
       work_batch_size_(1),
       task_count_(0),
-      task_time_tracker_(nullptr),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
       currently_executing_task_queue_(nullptr),
       observer_(nullptr),
       deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(delegate->RunsTasksOnCurrentThread());
@@ skipping 130 matching lines @@
     base::AutoLock lock(other_thread_lock_);
     other_thread_pending_wakeups_.erase(run_time);
   }
 
   if (!delegate_->IsNested())
     queues_to_delete_.clear();
 
   LazyNow lazy_now(real_time_domain()->CreateLazyNow());
   base::TimeTicks task_start_time;
 
-  if (!delegate_->IsNested() && task_time_tracker_)
+  if (!delegate_->IsNested() && task_time_trackers_.might_have_observers())
     task_start_time = lazy_now.Now();
 
   // Pass false and nullptr to UpdateWorkQueues here to prevent waking up a
   // pump-after-wakeup queue.
   UpdateWorkQueues(false, nullptr, lazy_now);
 
   internal::TaskQueueImpl::Task previous_task;
 
   for (int i = 0; i < work_batch_size_; i++) {
     internal::WorkQueue* work_queue;
@@ skipping 10 matching lines @@
         // means deferred tasks (i.e. non-nestable tasks) will never trigger
         // queue wake-ups.
         continue;
       case ProcessTaskResult::EXECUTED:
         break;
       case ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED:
         return;  // The TaskQueueManager got deleted, we must bail out.
     }
 
     lazy_now = real_time_domain()->CreateLazyNow();
-    if (!delegate_->IsNested() && task_time_tracker_) {
+    if (!delegate_->IsNested() && task_time_trackers_.might_have_observers()) {
       // Only report top level task durations.
       base::TimeTicks task_end_time = lazy_now.Now();
-      task_time_tracker_->ReportTaskTime(task_start_time, task_end_time);
+      FOR_EACH_OBSERVER(TaskTimeTracker, task_time_trackers_,
+                        ReportTaskTime(MonotonicTimeInSeconds(task_start_time),
+                                       MonotonicTimeInSeconds(task_end_time)));
       task_start_time = task_end_time;

[alph, 2016/08/22 23:51:07]

Looks like the first time the observer will get a bogus times. The
task_start_time is not initialized as there were no observers in the beginning.

[panickercorp, 2016/08/23 17:43:31]

There can be an issue if there are 0 observers at line 204 and an observer is
added before line 235.
In practice I don't think it's an issue as the renderer-scheduler is registered
as observer early on in its constructor. UNLESS the WorkerScheduler is created
beforehand and already processing tasks when the renderer-scheduler is created.

To be safe I could initialize task_start_time to base::TimeTicks() and add an
additional check here task_start_time != base::TimeTicks() (appears to be a
common pattern for checking validity of TimeTicks)

OTOH if this is not strictly necessary it could be needless overhead to do this
check per task. So maybe a comment instead?
Sami - any suggestions?

[panicker, 2016/08/25 23:11:52]

I'm leaving this as is, as this is not worse than today i.e. in theory
task_time_tracker_ could change from null to non-null between the 2 checks.

[Sami, 2016/08/26 11:03:56]

Sorry, I missed this question earlier. I think it would make sense to replace
the second might_have_observers() check with task_start_time ==
base::TimeTicks() check. It's not an error to call FOR_EACH_OBSERVER when there
are no observers. This would mean the clients don't need to guard against bogus
values.

     }
 
     work_queue = nullptr;  // The queue may have been unregistered.
 
     UpdateWorkQueues(should_trigger_wakeup, &previous_task, lazy_now);
 
     // Only run a single task per batch in nested run loops so that we can
     // properly exit the nested loop when someone calls RunLoop::Quit().
     if (delegate_->IsNested())
       break;
@@ skipping 121 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   task_observers_.AddObserver(task_observer);
 }
 
 void TaskQueueManager::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   task_observers_.RemoveObserver(task_observer);
 }
 
+void TaskQueueManager::AddTaskTimeTracker(TaskTimeTracker* task_time_tracker) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  task_time_trackers_.AddObserver(task_time_tracker);
+}
+
+void TaskQueueManager::RemoveTaskTimeTracker(
+    TaskTimeTracker* task_time_tracker) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  task_time_trackers_.RemoveObserver(task_time_tracker);
+}
+
 bool TaskQueueManager::GetAndClearSystemIsQuiescentBit() {
   bool task_was_run = task_was_run_on_quiescence_monitored_queue_;
   task_was_run_on_quiescence_monitored_queue_ = false;
   return !task_was_run;
 }
 
 const scoped_refptr<TaskQueueManagerDelegate>& TaskQueueManager::delegate()
     const {
   return delegate_;
 }
@@ skipping 47 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!work_queue->Empty());
   if (observer_) {
     observer_->OnTriedToExecuteBlockedTask(*work_queue->task_queue(),
                                            *work_queue->GetFrontTask());
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink