Kills TraceTicks, which was functionally the same as TimeTicks

components/scheduler/child/idle_helper.cc

 // Copyright 2015 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 "components/scheduler/child/idle_helper.h"
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/base/task_queue.h"
@@ skipping 341 matching lines @@
   helper_->CheckOnValidThread();
   if (new_state == idle_period_state_) {
     DCHECK_EQ(new_deadline, idle_period_deadline_);
     return;
   }
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
     base::TimeTicks now(optional_now.is_null() ? helper_->Now() : optional_now);
-    base::TraceTicks trace_now = base::TraceTicks::Now();
-    idle_period_deadline_for_tracing_ = trace_now + (new_deadline - now);
     TraceEventIdlePeriodStateChange(
-        new_state, running_idle_task_for_tracing_,
-        idle_period_deadline_for_tracing_, trace_now);
+        new_state, running_idle_task_for_tracing_, idle_period_deadline_, now);
   }
 
   idle_period_state_ = new_state;
   idle_period_deadline_ = new_deadline;
 
   // Inform the delegate if we are starting or ending an idle period.
   if (IsInIdlePeriod(new_state) && !IsInIdlePeriod(old_idle_period_state)) {
     delegate_->OnIdlePeriodStarted();
   } else if (!IsInIdlePeriod(new_state) &&
              IsInIdlePeriod(old_idle_period_state)) {
     delegate_->OnIdlePeriodEnded();
   }
 }
 
 void IdleHelper::State::TraceIdleIdleTaskStart() {
   helper_->CheckOnValidThread();
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
     TraceEventIdlePeriodStateChange(
-        idle_period_state_, true, idle_period_deadline_for_tracing_,
-        base::TraceTicks::Now());
+        idle_period_state_, true, idle_period_deadline_,
+        base::TimeTicks::Now());
   }
 }
 
 void IdleHelper::State::TraceIdleIdleTaskEnd() {
   helper_->CheckOnValidThread();
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
   if (is_tracing) {
     TraceEventIdlePeriodStateChange(
-        idle_period_state_, false, idle_period_deadline_for_tracing_,
-        base::TraceTicks::Now());
+        idle_period_state_, false, idle_period_deadline_,
+        base::TimeTicks::Now());
   }
 }
 
 void IdleHelper::State::TraceEventIdlePeriodStateChange(
     IdlePeriodState new_state,
     bool new_running_idle_task,
-    base::TraceTicks new_deadline,
-    base::TraceTicks now) {
+    base::TimeTicks new_deadline,
+    base::TimeTicks now) {
   TRACE_EVENT2(disabled_by_default_tracing_category_, "SetIdlePeriodState",
                "old_state",
                IdleHelper::IdlePeriodStateToString(idle_period_state_),
                "new_state", IdleHelper::IdlePeriodStateToString(new_state));
 
   if (idle_period_trace_event_started_ && running_idle_task_for_tracing_ &&
       !new_running_idle_task) {
     running_idle_task_for_tracing_ = false;
-    if (!idle_period_deadline_for_tracing_.is_null() &&
-        now > idle_period_deadline_for_tracing_) {
+    if (!idle_period_deadline_.is_null() && now > idle_period_deadline_) {
       TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(
           tracing_category_, idle_period_tracing_name_, this,
           "DeadlineOverrun",
-          std::max(idle_period_deadline_for_tracing_,
-                   last_idle_task_trace_time_).ToInternalValue());
+          std::max(idle_period_deadline_,
+                   last_idle_task_time_).ToInternalValue());
     }
   }
 
   if (IsInIdlePeriod(new_state)) {
     if (!idle_period_trace_event_started_) {
       idle_period_trace_event_started_ = true;
       TRACE_EVENT_ASYNC_BEGIN1(
           tracing_category_, idle_period_tracing_name_, this,
           "idle_period_length_ms", (new_deadline - now).ToInternalValue());
     }
 
     if (new_running_idle_task) {
-      last_idle_task_trace_time_ = now;
+      last_idle_task_time_ = now;
       running_idle_task_for_tracing_ = true;
       TRACE_EVENT_ASYNC_STEP_INTO0(
           tracing_category_, idle_period_tracing_name_, this,
           "RunningIdleTask");
     } else if (new_state == IdlePeriodState::IN_SHORT_IDLE_PERIOD) {
       TRACE_EVENT_ASYNC_STEP_INTO0(
           tracing_category_, idle_period_tracing_name_, this,
           "ShortIdlePeriod");
     } else if (IsInLongIdlePeriod(new_state) &&
         new_state != IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
@@ skipping 25 matching lines @@
       return "in_long_idle_period_with_max_deadline";
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler