Delete all use of tick_util.h.

webrtc/system_wrappers/test/TestSort/TestSort.cc

 /*
  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <stdio.h>
 #include <string.h>
 
 #include <algorithm>
 
+#include "webrtc/base/timeutils.h"
 #include "webrtc/system_wrappers/include/sort.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
 
 // Excellent work polluting the global namespace Visual Studio...
 #undef max
 #undef min
 #include <limits>
 
 template<typename KeyType>
 struct LotsOfData
 {
     KeyType key;
@@ skipping 109 matching lines @@
 
     if (keySort)
     {
         printf("Running %s KeySort() tests...\n", TypeEnumToString(sortType));
     }
     else
     {
         printf("Running %s Sort() tests...\n", TypeEnumToString(sortType));
     }
 
-    TickInterval accTicks;
+    int64_t accTicks;
     for (int i = 0; i < NumOfTests; i++)
     {
         for (int j = 0; j < DataLength; j++)
         {
             key[j] = TypedRand<KeyType>();
             data[j].key = key[j];
             // Write index to payload. We use this later for verification.
             sprintf(data[j].data, "%d", j);
         }
 
         memcpy(dataRef, data, sizeof(data));
         memcpy(keyRef, key, sizeof(key));
 
         retVal = 0;
-        TickTime t0 = TickTime::Now();
+        int64_t t0 = rtc::TimeNanos();
         if (keySort)
         {
             retVal = webrtc::KeySort(data, key, DataLength, sizeof(LotsOfData<KeyType>),
                 sortType);
 
             //std::sort(data, data + DataLength, KeyLessThan<KeyType>());
             //qsort(data, DataLength, sizeof(LotsOfData<KeyType>),
             //    CompareKey<LotsOfData<KeyType>, KeyType>);
         }
         else
         {
             retVal = webrtc::Sort(key, DataLength, sortType);
 
             //std::sort(key, key + DataLength);
             //qsort(key, DataLength, sizeof(KeyType), Compare<KeyType>);
         }
-        TickTime t1 = TickTime::Now();
+        int64_t t1 = rtc::TimeNanos();
         accTicks += (t1 - t0);
 
         if (retVal != 0)
         {
             printf("Test failed at iteration %d:\n", i);
             printf("Sort returned an error. ");
             printf("It likely does not support the requested type\nExiting...\n");
             exit(0);
         }
 
@@ skipping 39 matching lines @@
             {
                 printf("Test failed at iteration %d:\n", i);
                 printf("Sort data differs from std::sort reference\nExiting...\n");
                 exit(0);
             }
         }
     }
 
     printf("Compliance test passed over %d iterations\n", NumOfTests);
 
-    int64_t executeTime = accTicks.Milliseconds();
+    int64_t executeTime = accTicks / rtc::kNumNanosecsPerMillisec;
     printf("Execute time: %.2f s\n\n", (float)executeTime / 1000);
 }
 
 int main()
 {
     // Seed rand().
     srand(42);
     bool keySort = false;
     for (int i = 0; i < 2; i++) {
         RunSortTest<int8_t>(webrtc::TYPE_Word8, keySort);
         RunSortTest<uint8_t>(webrtc::TYPE_UWord8, keySort);
         RunSortTest<int16_t>(webrtc::TYPE_Word16, keySort);
         RunSortTest<uint16_t>(webrtc::TYPE_UWord16, keySort);
         RunSortTest<int32_t>(webrtc::TYPE_Word32, keySort);
         RunSortTest<uint32_t>(webrtc::TYPE_UWord32, keySort);
         RunSortTest<int64_t>(webrtc::TYPE_Word64, keySort);
         RunSortTest<uint64_t>(webrtc::TYPE_UWord64, keySort);
         RunSortTest<float>(webrtc::TYPE_Float32, keySort);
         RunSortTest<double>(webrtc::TYPE_Float64, keySort);
 
         keySort = !keySort;
     }
 
     printf("All tests passed\n");
 
     return 0;
 }