Fixit: Fork base::TimeTicks --> TimeTicks + ThreadTicks + TraceTicks

base/trace_event/trace_event_unittest.cc

 // Copyright (c) 2012 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 <math.h>
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 2278 matching lines @@
                             const std::string& category,
                             const std::string& name) {
     EXPECT_EQ(phase, collected_events_phases_[i]);
     EXPECT_EQ(category, collected_events_categories_[i]);
     EXPECT_EQ(name, collected_events_names_[i]);
   }
 
   std::vector<std::string> collected_events_categories_;
   std::vector<std::string> collected_events_names_;
   std::vector<unsigned char> collected_events_phases_;
-  std::vector<TimeTicks> collected_events_timestamps_;
+  std::vector<TraceTicks> collected_events_timestamps_;
 
   static TraceEventCallbackTest* s_instance;
-  static void Callback(TimeTicks timestamp,
+  static void Callback(TraceTicks timestamp,
                        char phase,
                        const unsigned char* category_group_enabled,
                        const char* name,
                        unsigned long long id,
                        int num_args,
                        const char* const arg_names[],
                        const unsigned char arg_types[],
                        const unsigned long long arg_values[],
                        unsigned char flags) {
     s_instance->collected_events_phases_.push_back(phase);
@@ skipping 178 matching lines @@
 
 TEST_F(TraceEventTestFixture, TraceBufferVectorReportFull) {
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(CategoryFilter("*"),
                         TraceLog::RECORDING_MODE,
                         TraceOptions());
   trace_log->logged_events_.reset(
       trace_log->CreateTraceBufferVectorOfSize(100));
   do {
     TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
-        "all", "with_timestamp", 0, 0,
-        TimeTicks::NowFromSystemTraceTime().ToInternalValue());
+        "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue());
     TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(
-        "all", "with_timestamp", 0, 0,
-        TimeTicks::NowFromSystemTraceTime().ToInternalValue());
+        "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue());
   } while (!trace_log->BufferIsFull());
 
   EndTraceAndFlush();
 
   const DictionaryValue* trace_full_metadata = NULL;
 
   trace_full_metadata = FindTraceEntry(trace_parsed_,
                                        "overflowed_at_ts");
   std::string phase;
   double buffer_limit_reached_timestamp = 0;
@@ skipping 352 matching lines @@
     TRACE_EVENT0("b", "duration");
   }
 
   EndTraceAndFlush();
   logging::SetLogMessageHandler(old_log_message_handler);
 }
 
 TEST_F(TraceEventTestFixture, TimeOffset) {
   BeginTrace();
   // Let TraceLog timer start from 0.
-  TimeDelta time_offset = TimeTicks::NowFromSystemTraceTime() - TimeTicks();
+  TimeDelta time_offset = TraceTicks::Now() - TraceTicks();
   TraceLog::GetInstance()->SetTimeOffset(time_offset);
 
   {
     TRACE_EVENT0("all", "duration1");
     TRACE_EVENT0("all", "duration2");
   }
   TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
-      "all", "with_timestamp", 0, 0,
-      TimeTicks::NowFromSystemTraceTime().ToInternalValue());
+      "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue());
   TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(
-      "all", "with_timestamp", 0, 0,
-      TimeTicks::NowFromSystemTraceTime().ToInternalValue());
+      "all", "with_timestamp", 0, 0, TraceTicks::Now().ToInternalValue());
 
   EndTraceAndFlush();
   DropTracedMetadataRecords();
 
   double end_time = static_cast<double>(
-      (TimeTicks::NowFromSystemTraceTime() - time_offset).ToInternalValue());
+      (TraceTicks::Now() - time_offset).ToInternalValue());
   double last_timestamp = 0;
   for (size_t i = 0; i < trace_parsed_.GetSize(); ++i) {
     const DictionaryValue* item;
     EXPECT_TRUE(trace_parsed_.GetDictionary(i, &item));
     double timestamp;
     EXPECT_TRUE(item->GetDouble("ts", &timestamp));
     EXPECT_GE(timestamp, last_timestamp);
     EXPECT_LE(timestamp, end_time);
     last_timestamp = timestamp;
   }
@@ skipping 37 matching lines @@
 }
 
 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) {
   const char config[] = "DELAY(test.Delay;16;oneshot)";
   CategoryFilter filter(config);
   EXPECT_EQ(config, filter.ToString());
 }
 
 }  // namespace trace_event
 }  // namespace base