Fix incorrect opus seek preroll and flaky pre-skip removal.

media/audio/clockless_audio_sink.cc

 // Copyright 2013 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 "media/audio/clockless_audio_sink.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/simple_thread.h"
+#include "media/base/audio_hash.h"
 
 namespace media {
 
 // Internal to ClocklessAudioSink. Class is used to call Render() on a seperate
 // thread, running as fast as it can read the data.
 class ClocklessAudioSinkThread : public base::DelegateSimpleThread::Delegate {
  public:
-  explicit ClocklessAudioSinkThread(const AudioParameters& params,
-                                    AudioRendererSink::RenderCallback* callback)
+  ClocklessAudioSinkThread(const AudioParameters& params,
+                           AudioRendererSink::RenderCallback* callback,
+                           bool hashing)
       : callback_(callback),
         audio_bus_(AudioBus::Create(params)),
-        stop_event_(new base::WaitableEvent(false, false)) {}
+        stop_event_(new base::WaitableEvent(false, false)) {
+    if (hashing)
+      audio_hash_.reset(new AudioHash());
+  }
 
   void Start() {
     stop_event_->Reset();
     thread_.reset(new base::DelegateSimpleThread(this, "ClocklessAudioSink"));
     thread_->Start();
   }
 
   // Generate a signal to stop calling Render().
   base::TimeDelta Stop() {
     stop_event_->Signal();
     thread_->Join();
     return playback_time_;
   }
 
+  std::string GetAudioHash() {
+    return audio_hash_->ToString();

[wolenetz, 2015/07/29 21:57:27]

nit: Is this for test only (I think so)? If not, then this might hit NPE on null
audio_hash_.get() if called without |hashing| true in ctor. Include "ForTesting"
in the name?

[DaleCurtis, 2015/07/30 01:28:14]

It is only for testing, but I can't add ForTesting() because presubmit isn't
smart enough to figure out that one ForTesting method has called another
ForTesting() method. I added a DCHECK().

[wolenetz, 2015/08/06 22:21:27]

Acknowledged.

+  }
+
  private:
    // Call Render() repeatedly, keeping track of the rendering time.
   void Run() override {
      base::TimeTicks start;
      while (!stop_event_->IsSignaled()) {
        int frames_received = callback_->Render(audio_bus_.get(), 0);
+       if (audio_hash_)
+         audio_hash_->Update(audio_bus_.get(), frames_received);

[wolenetz, 2015/07/29 21:57:27]

hmm. Could frames_received indeed be negative (see next line which implies
this)? If so, AudioHash::Update() casts int to uint32 and negative would be a
problem.

[DaleCurtis, 2015/07/30 01:28:14]

No, it's always >= 0. I've added a DCHECK and fixed the misleading conditional.

[wolenetz, 2015/08/06 22:21:27]

Acknowledged.

        if (frames_received <= 0) {
          // No data received, so let other threads run to provide data.
          base::PlatformThread::YieldCurrentThread();
        } else if (start.is_null()) {
          // First time we processed some audio, so record the starting time.
          start = base::TimeTicks::Now();
        } else {
          // Keep track of the last time data was rendered.
          playback_time_ = base::TimeTicks::Now() - start;
        }
      }
    }
 
   AudioRendererSink::RenderCallback* callback_;
   scoped_ptr<AudioBus> audio_bus_;
   scoped_ptr<base::WaitableEvent> stop_event_;
   scoped_ptr<base::DelegateSimpleThread> thread_;
   base::TimeDelta playback_time_;
+  scoped_ptr<AudioHash> audio_hash_;
 };
 
 ClocklessAudioSink::ClocklessAudioSink()
-    : initialized_(false),
-      playing_(false) {}
+    : initialized_(false), playing_(false), hashing_(false) {}
 
 ClocklessAudioSink::~ClocklessAudioSink() {}
 
 void ClocklessAudioSink::Initialize(const AudioParameters& params,
                                     RenderCallback* callback) {
   DCHECK(!initialized_);
-  thread_.reset(new ClocklessAudioSinkThread(params, callback));
+  thread_.reset(new ClocklessAudioSinkThread(params, callback, hashing_));
   initialized_ = true;
 }
 
 void ClocklessAudioSink::Start() {
   DCHECK(initialized_);
   DCHECK(!playing_);
 }
 
 void ClocklessAudioSink::Stop() {
   if (initialized_)
@@ skipping 25 matching lines @@
   return volume == 0.0;
 }
 
 void ClocklessAudioSink::SwitchOutputDevice(
     const std::string& device_id,
     const GURL& security_origin,
     const SwitchOutputDeviceCB& callback) {
   callback.Run(SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_SUPPORTED);
 }
 
+void ClocklessAudioSink::StartAudioHashForTesting() {
+  DCHECK(!initialized_);
+  hashing_ = true;
+}
+
+std::string ClocklessAudioSink::GetAudioHashForTesting() {
+  return thread_ && hashing_ ? thread_->GetAudioHash() : std::string();
+}
+
 }  // namespace media