Revert 108752 - Support tracking of IPC messages as tasks in profiler

base/tracked_objects.h

 // Copyright (c) 2011 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_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 #pragma once
 
 #include <map>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/location.h"
-#include "base/profiler/tracked_time.h"
 #include "base/time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local_storage.h"
 #include "base/tracking_info.h"
 #include "base/values.h"
 
+#if defined(OS_WIN)
+#include <mmsystem.h>  // Declare timeGetTime();
+#endif
+
 // TrackedObjects provides a database of stats about objects (generally Tasks)
 // that are tracked.  Tracking means their birth, death, duration, birth thread,
 // death thread, and birth place are recorded.  This data is carefully spread
 // across a series of objects so that the counts and times can be rapidly
 // updated without (usually) having to lock the data, and hence there is usually
 // very little contention caused by the tracking.  The data can be viewed via
 // the about:tracking URL, with a variety of sorting and filtering choices.
 //
 // These classes serve as the basis of a profiler of sorts for the Tasks system.
 // As a result, design decisions were made to maximize speed, by minimizing
@@ skipping 130 matching lines @@
 // For basic profiling, this will work "most of the time," and should be
 // sufficient... but storing away DataCollections is the "right way" to do this.
 // We'll accomplish this via JavaScript storage of snapshots, and then we'll
 // remove the Reset() methods.
 
 class MessageLoop;
 
 namespace tracked_objects {
 
 //------------------------------------------------------------------------------
+
+#define USE_FAST_TIME_CLASS_FOR_DURATION_CALCULATIONS
+
+#if defined(USE_FAST_TIME_CLASS_FOR_DURATION_CALCULATIONS)
+
+// TimeTicks maintains a wasteful 64 bits of data (we need less than 32), and on
+// windows, a 64 bit timer is expensive to even obtain. We use a simple
+// millisecond counter for most of our time values, as well as millisecond units
+// of duration between those values.  This means we can only handle durations
+// up to 49 days (range), or 24 days (non-negative time durations).
+// We only define enough methods to service the needs of the tracking classes,
+// and our interfaces are modeled after what TimeTicks and TimeDelta use (so we
+// can swap them into place if we want to use the "real" classes).
+
+class BASE_EXPORT Duration {  // Similar to base::TimeDelta.
+ public:
+  Duration() : ms_(0) {}
+
+  Duration& operator+=(const Duration& other) {
+    ms_ += other.ms_;
+    return *this;
+  }
+
+  Duration operator+(const Duration& other) const {
+    return Duration(ms_ + other.ms_);
+  }
+
+  bool operator==(const Duration& other) const { return ms_ == other.ms_; }
+  bool operator!=(const Duration& other) const { return ms_ != other.ms_; }
+  bool operator>(const Duration& other) const { return ms_ > other.ms_; }
+
+  static Duration FromMilliseconds(int ms) { return Duration(ms); }
+
+  int32 InMilliseconds() const { return ms_; }
+
+ private:
+  friend class TrackedTime;
+  explicit Duration(int32 duration) : ms_(duration) {}
+
+  // Internal time is stored directly in milliseconds.
+  int32 ms_;
+};
+
+class BASE_EXPORT TrackedTime {  // Similar to base::TimeTicks.
+ public:
+  TrackedTime() : ms_(0) {}
+  explicit TrackedTime(const base::TimeTicks& time)
+      : ms_((time - base::TimeTicks()).InMilliseconds()) {
+  }
+
+  static TrackedTime Now() {
+#if defined(OS_WIN)
+    // Use lock-free accessor to 32 bit time.
+    // Note that TimeTicks::Now() is built on this, so we have "compatible"
+    // times when we down-convert a TimeTicks sample.
+    // TODO(jar): Surface this interface via something in base/time.h.
+    return TrackedTime(static_cast<int32>(::timeGetTime()));
+#else
+    // Posix has nice cheap 64 bit times, so we just down-convert it.
+    return TrackedTime(base::TimeTicks::Now());
+#endif  // OS_WIN
+  }
+
+  Duration operator-(const TrackedTime& other) const {
+    return Duration(ms_ - other.ms_);
+  }
+
+  TrackedTime operator+(const Duration& other) const {
+    return TrackedTime(ms_ + other.ms_);
+  }
+
+  bool is_null() const { return ms_ == 0; }
+
+ private:
+  friend class Duration;
+  explicit TrackedTime(int32 ms) : ms_(ms) {}
+
+  // Internal duration is stored directly in milliseconds.
+  uint32 ms_;
+};
+
+#else
+
+// Just use full 64 bit time calculations, and the slower TimeTicks::Now().
+typedef base::TimeTicks TrackedTime;
+typedef base::TimeDelta Duration;
+
+#endif  // USE_FAST_TIME_CLASS_FOR_DURATION_CALCULATIONS
+
+//------------------------------------------------------------------------------
 // For a specific thread, and a specific birth place, the collection of all
 // death info (with tallies for each death thread, to prevent access conflicts).
 class ThreadData;
 class BASE_EXPORT BirthOnThread {
  public:
   BirthOnThread(const Location& location, const ThreadData& current);
 
   const Location location() const { return location_; }
   const ThreadData* birth_thread() const { return birth_thread_; }
 
@@ skipping 430 matching lines @@
   // The |start_of_run| is when the worker thread started to perform the run of
   // the task.
   // The |end_of_run| was just obtained by a call to Now() (just after the task
   // finished).
   static void TallyRunOnWorkerThreadIfTracking(
       const Births* birth,
       const TrackedTime& time_posted,
       const TrackedTime& start_of_run,
       const TrackedTime& end_of_run);
 
-  // Record the end of execution in region, generally corresponding to a scope
-  // being exited.
-  static void TallyRunInAScopedRegionIfTracking(
-      const Births* birth,
-      const TrackedTime& start_of_run,
-      const TrackedTime& end_of_run);
-
   const std::string thread_name() const { return thread_name_; }
 
   // ---------------------
-  // TODO(jar):
   // The following functions should all be private, and are only public because
   // the collection is done externally.  We need to relocate that code from the
   // collection class into this class, and then all these methods can be made
   // private.
   // (Thread safe) Get start of list of all ThreadData instances.
   static ThreadData* first();
   // Iterate through the null terminated list of ThreadData instances.
   ThreadData* next() const { return next_; }
   // Using our lock, make a copy of the specified maps.  These calls may arrive
   // from non-local threads, and are used to quickly scan data from all threads
@@ skipping 162 matching lines @@
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_