Kills TraceTicks, which was functionally the same as TimeTicks

base/trace_event/trace_event_impl.h

 // 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.
 
 
 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
@@ skipping 77 matching lines @@
 
   TraceEvent();
   ~TraceEvent();
 
   // We don't need to copy TraceEvent except when TraceEventBuffer is cloned.
   // Use explicit copy method to avoid accidentally misuse of copy.
   void CopyFrom(const TraceEvent& other);
 
   void Initialize(
       int thread_id,
-      TraceTicks timestamp,
+      TimeTicks timestamp,
       ThreadTicks thread_timestamp,
       char phase,
       const unsigned char* category_group_enabled,
       const char* name,
       unsigned long long id,
       unsigned long long context_id,
       unsigned long long bind_id,
       int num_args,
       const char** arg_names,
       const unsigned char* arg_types,
       const unsigned long long* arg_values,
       const scoped_refptr<ConvertableToTraceFormat>* convertable_values,
       unsigned int flags);
 
   void Reset();
 
-  void UpdateDuration(const TraceTicks& now, const ThreadTicks& thread_now);
+  void UpdateDuration(const TimeTicks& now, const ThreadTicks& thread_now);
 
   void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
 
   // Serialize event data to JSON
   void AppendAsJSON(
       std::string* out,
       const ArgumentFilterPredicate& argument_filter_predicate) const;
   void AppendPrettyPrinted(std::ostringstream* out) const;
 
   static void AppendValueAsJSON(unsigned char type,
                                 TraceValue value,
                                 std::string* out);
 
-  TraceTicks timestamp() const { return timestamp_; }
+  TimeTicks timestamp() const { return timestamp_; }
   ThreadTicks thread_timestamp() const { return thread_timestamp_; }
   char phase() const { return phase_; }
   int thread_id() const { return thread_id_; }
   TimeDelta duration() const { return duration_; }
   TimeDelta thread_duration() const { return thread_duration_; }
   unsigned long long id() const { return id_; }
   unsigned long long context_id() const { return context_id_; }
   unsigned int flags() const { return flags_; }
 
   // Exposed for unittesting:
 
   const base::RefCountedString* parameter_copy_storage() const {
     return parameter_copy_storage_.get();
   }
 
   const unsigned char* category_group_enabled() const {
     return category_group_enabled_;
   }
 
   const char* name() const { return name_; }
 
 #if defined(OS_ANDROID)
   void SendToATrace();
 #endif
 
  private:
   // Note: these are ordered by size (largest first) for optimal packing.
-  TraceTicks timestamp_;
+  TimeTicks timestamp_;
   ThreadTicks thread_timestamp_;
   TimeDelta duration_;
   TimeDelta thread_duration_;
   // id_ can be used to store phase-specific data.
   unsigned long long id_;
   // context_id_ is used to store context information.
   unsigned long long context_id_;
   TraceValue arg_values_[kTraceMaxNumArgs];
   const char* arg_names_[kTraceMaxNumArgs];
   scoped_refptr<ConvertableToTraceFormat> convertable_values_[kTraceMaxNumArgs];
@@ skipping 12 matching lines @@
   unsigned char arg_types_[kTraceMaxNumArgs];
   char phase_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceEvent);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_