Add polling and audio check to copresence.

components/copresence/handlers/audio/audio_directive_handler_unittest.cc

 // Copyright 2014 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/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/timer/mock_timer.h"
 #include "components/copresence/handlers/audio/audio_directive_handler_impl.h"
 #include "components/copresence/handlers/audio/tick_clock_ref_counted.h"
 #include "components/copresence/mediums/audio/audio_manager.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/test/audio_test_support.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace copresence {
 
-namespace {
-
-// Callback stubs to pass into the directive handler.
-void DecodeSamples(AudioType, const std::string&) {
-}
-void EncodeToken(const std::string&,
-                 AudioType,
-                 const AudioManager::SamplesCallback&) {
-}
-
-}  // namespace
-
 class AudioManagerStub final : public AudioManager {
  public:
   AudioManagerStub() {}
   ~AudioManagerStub() override {}
 
   // AudioManager overrides:
-  void Initialize(const DecodeSamplesCallback& decode_cb,
-                  const EncodeTokenCallback& encode_cb) override {}
+  void Initialize(WhispernetClient* whispernet_client,
+                  const TokensCallback& tokens_cb) override {}
   void StartPlaying(AudioType type) override { playing_[type] = true; }
   void StopPlaying(AudioType type) override { playing_[type] = false; }
   void StartRecording(AudioType type) override { recording_[type] = true; }
   void StopRecording(AudioType type) override { recording_[type] = false; }
   void SetToken(AudioType type, const std::string& url_unsafe_token) override {}
   const std::string GetToken(AudioType type) override { return std::string(); }
   bool IsRecording(AudioType type) override { return recording_[type]; }
   bool IsPlaying(AudioType type) override { return playing_[type]; }
+  bool IsPlayingTokenHeard(AudioType type) override { return false; }
 
  private:
   // Indexed using enum AudioType.
   bool playing_[2];
   bool recording_[2];
 
   DISALLOW_COPY_AND_ASSIGN(AudioManagerStub);
 };
 
 class AudioDirectiveHandlerTest : public testing::Test {
  public:
   AudioDirectiveHandlerTest() {
     manager_ptr_ = new AudioManagerStub;
     timer_ptr_ = new base::MockTimer(false, false);
     clock_ptr_ = new base::SimpleTestTickClock;
 
     directive_handler_.reset(new AudioDirectiveHandlerImpl(
         make_scoped_ptr<AudioManager>(manager_ptr_),
         make_scoped_ptr<base::Timer>(timer_ptr_),
         make_scoped_refptr(new TickClockRefCounted(clock_ptr_))));
-    directive_handler_->Initialize(base::Bind(&DecodeSamples),
-                                   base::Bind(&EncodeToken));
+    directive_handler_->Initialize(NULL, TokensCallback());

[Charlie, 2014/11/06 17:28:22]

Pass a StubWhispernetClient here instead (owned by a local scoped_ptr). And
DCHECK whispernet in the AudioManager.

[rkc, 2014/11/06 19:58:24]

Why do I need to pass in a Stub to DCHECK in the AudioManager?

[Charlie, 2014/11/06 21:53:14]

In the real implementation, WhispernetClient shouldn't be null, and we want an
error when it is. Tests shouldn't interfere with prod behavior.

[rkc, 2014/11/06 21:58:33]

We will never get to the point that Whispernet will be used. That is the whole
point of having a stub. If at any point this behavior changes, this *test* will
crash, so we should be fine.

   }
   ~AudioDirectiveHandlerTest() override {}
 
  protected:
   TokenInstruction CreateTransmitInstruction(const std::string& token,
                                              bool audible) {
     TokenInstruction instruction;
     instruction.set_token_instruction_type(TRANSMIT);
     instruction.set_token_id(token);
     instruction.set_medium(audible ? AUDIO_AUDIBLE_DTMF
@@ skipping 113 matching lines @@
 
   // We are now at base + 2676ms.
   timer_ptr_->Fire();
   EXPECT_FALSE(IsRecording(AUDIBLE));
 }
 
 // TODO(rkc): Write more tests that check more convoluted sequences of
 // transmits/receives.
 
 }  // namespace copresence