Replace erroneous use of base::Time with base::TimeTicks throughout media code.

media/audio/win/audio_unified_win_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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/test/test_timeouts.h"
@@ skipping 45 matching lines @@
   MOCK_METHOD1(OnError, void(AudioOutputStream* stream));
 };
 
 // AudioOutputStream::AudioSourceCallback implementation which enables audio
 // play-through. It also creates a text file that contains times between two
 // successive callbacks. Units are in milliseconds. This file can be used for
 // off-line analysis of the callback sequence.
 class UnifiedSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit UnifiedSourceCallback()
-      : previous_call_time_(base::Time::Now()),
+      : previous_call_time_(base::TimeTicks::Now()),
         text_file_(NULL),
         elements_to_write_(0) {
     delta_times_.reset(new int[kMaxDeltaSamples]);
   }
 
   virtual ~UnifiedSourceCallback() {
     base::FilePath file_name;
     EXPECT_TRUE(PathService::Get(base::DIR_EXE, &file_name));
     file_name = file_name.AppendASCII(kDeltaTimeMsFileName);
 
@@ skipping 14 matching lines @@
   virtual int OnMoreData(AudioBus* dest,
                          AudioBuffersState buffers_state) {
     NOTREACHED();
     return 0;
   };
 
   virtual int OnMoreIOData(AudioBus* source,
                            AudioBus* dest,
                            AudioBuffersState buffers_state) {
     // Store time between this callback and the previous callback.
-    int diff = (base::Time::Now() - previous_call_time_).InMilliseconds();
-    previous_call_time_ = base::Time::Now();
+    const base::TimeTicks now_time = base::TimeTicks::Now();
+    const int diff = (now_time - previous_call_time_).InMilliseconds();
+    previous_call_time_ = now_time;
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
 
     // Play out the recorded audio samples in loop back. Perform channel mixing
     // if required using a channel mixer which is created only if needed.
     if (source->channels() == dest->channels())
       source->CopyTo(dest);
     else {
@@ skipping 14 matching lines @@
         channel_mixer_->Transform(source, dest);
     }
     return source->frames();
   };
 
   virtual void OnError(AudioOutputStream* stream) {
     NOTREACHED();
   }
 
  private:
-  base::Time previous_call_time_;
+  base::TimeTicks previous_call_time_;
   scoped_ptr<int[]> delta_times_;
   FILE* text_file_;
   size_t elements_to_write_;
   scoped_ptr<ChannelMixer> channel_mixer_;
 };
 
 // Convenience method which ensures that we fulfill all required conditions
 // to run unified audio tests on Windows.
 static bool CanRunUnifiedAudioTests(AudioManager* audio_man) {
  if (!CoreAudioUtil::IsSupported()) {
@@ skipping 164 matching lines @@
 
   EXPECT_TRUE(wus->Open());
   wus->Start(&source);
   loop.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
                        base::TimeDelta::FromMilliseconds(10000));
   loop.Run();
   wus->Close();
 }
 
 }  // namespace media