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

media/audio/win/audio_low_latency_output_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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
@@ skipping 59 matching lines @@
                                  AudioBuffersState buffers_state));
   MOCK_METHOD1(OnError, void(AudioOutputStream* stream));
 };
 
 // This audio source implementation should be used for manual tests only since
 // it takes about 20 seconds to play out a file.
 class ReadFromFileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit ReadFromFileAudioSource(const std::string& name)
     : pos_(0),
-      previous_call_time_(base::Time::Now()),
+      previous_call_time_(base::TimeTicks::Now()),
       text_file_(NULL),
       elements_to_write_(0) {
     // Reads a test file from media/test/data directory.
     file_ = ReadTestDataFile(name);
 
     // Creates an array that will store delta times between callbacks.
     // The content of this array will be written to a text file at
     // destruction and can then be used for off-line analysis of the exact
     // timing of callbacks. The text file will be stored in media/test/data.
     delta_times_.reset(new int[kMaxDeltaSamples]);
@@ skipping 18 matching lines @@
     }
 
     file_util::CloseFile(text_file_);
   }
 
   // AudioOutputStream::AudioSourceCallback implementation.
   virtual int OnMoreData(AudioBus* audio_bus,
                          AudioBuffersState buffers_state) {
     // Store time difference between two successive callbacks in an array.
     // These values will be written to a file in the destructor.
-    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_;
     }
 
     int max_size =
         audio_bus->frames() * audio_bus->channels() * kBitsPerSample / 8;
 
     // Use samples read from a data file and fill up the audio buffer
     // provided to us in the callback.
@@ skipping 16 matching lines @@
   }
 
   virtual void OnError(AudioOutputStream* stream) {}
 
   int file_size() { return file_->GetDataSize(); }
 
  private:
   scoped_refptr<DecoderBuffer> file_;
   scoped_ptr<int[]> delta_times_;
   int pos_;
-  base::Time previous_call_time_;
+  base::TimeTicks previous_call_time_;
   FILE* text_file_;
   size_t elements_to_write_;
 };
 
 static bool ExclusiveModeIsEnabled() {
   return (WASAPIAudioOutputStream::GetShareMode() ==
           AUDCLNT_SHAREMODE_EXCLUSIVE);
 }
 
 // Convenience method which ensures that we are not running on the build
@@ skipping 525 matching lines @@
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
                         TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 }  // namespace media