Redesign the copresence audio handlers.

chrome/browser/copresence/chrome_whispernet_client_browsertest.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 "chrome/browser/copresence/chrome_whispernet_client.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/api/copresence/copresence_api.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
+#include "components/copresence/public/copresence_constants.h"
 #include "media/base/audio_bus.h"
 
 namespace {
 
 const char kSixZeros[] = "MDAwMDAw";
 
 copresence::WhispernetClient* GetWhispernetClient(
     content::BrowserContext* context) {
   extensions::CopresenceService* service =
       extensions::CopresenceService::GetFactoryInstance()->Get(context);
@@ skipping 36 matching lines @@
   void EncodeTokenAndSaveSamples(bool audible) {
     copresence::WhispernetClient* client = GetWhispernetClient(context_);
     ASSERT_TRUE(client);
 
     run_loop_.reset(new base::RunLoop());
     client->RegisterSamplesCallback(base::Bind(
         &ChromeWhispernetClientTest::SamplesCallback, base::Unretained(this)));
     expected_token_ = kSixZeros;
     expected_audible_ = audible;
 
-    client->EncodeToken(kSixZeros, audible);
+    client->EncodeToken(kSixZeros,
+                        audible ? copresence::AUDIBLE : copresence::INAUDIBLE);
     run_loop_->Run();
 
     EXPECT_GT(saved_samples_->frames(), 0);
   }
 
   void DecodeSamplesAndVerifyToken(bool expect_audible) {
     copresence::WhispernetClient* client = GetWhispernetClient(context_);
     ASSERT_TRUE(client);
 
     run_loop_.reset(new base::RunLoop());
     client->RegisterTokensCallback(base::Bind(
         &ChromeWhispernetClientTest::TokensCallback, base::Unretained(this)));
     expected_token_ = kSixZeros;
     expected_audible_ = expect_audible;
 
     ASSERT_GT(saved_samples_->frames(), 0);
 
     // Convert our single channel samples to two channel. Decode samples
     // expects 2 channel data.
     scoped_refptr<media::AudioBusRefCounted> samples_bus =
         media::AudioBusRefCounted::Create(2, saved_samples_->frames());
     memcpy(samples_bus->channel(0),
            saved_samples_->channel(0),
            sizeof(float) * saved_samples_->frames());
     memcpy(samples_bus->channel(1),
            saved_samples_->channel(0),
            sizeof(float) * saved_samples_->frames());
 
-    client->DecodeSamples(AudioBusToString(samples_bus));
+    client->DecodeSamples(
+        expect_audible ? copresence::AUDIBLE : copresence::INAUDIBLE,
+        AudioBusToString(samples_bus));
     run_loop_->Run();
   }
 
   void DetectBroadcast() {
     copresence::WhispernetClient* client = GetWhispernetClient(context_);
     ASSERT_TRUE(client);
 
     run_loop_.reset(new base::RunLoop());
     client->RegisterDetectBroadcastCallback(
         base::Bind(&ChromeWhispernetClientTest::DetectBroadcastCallback,
                    base::Unretained(this)));
     client->DetectBroadcast();
     run_loop_->Run();
   }
 
  protected:
   void InitCallback(bool success) {
     EXPECT_TRUE(success);
     initialized_ = true;
     ASSERT_TRUE(run_loop_);
     run_loop_->Quit();
   }
 
   void SamplesCallback(
       const std::string& token,
-      bool audible,
+      copresence::AudioType type,
       const scoped_refptr<media::AudioBusRefCounted>& samples) {
     EXPECT_EQ(expected_token_, token);
-    EXPECT_EQ(expected_audible_, audible);
+    EXPECT_EQ(expected_audible_, type == copresence::AUDIBLE);
     saved_samples_ = samples;
     ASSERT_TRUE(run_loop_);
     run_loop_->Quit();
   }
 
   void TokensCallback(const std::vector<copresence::AudioToken>& tokens) {
     ASSERT_TRUE(run_loop_);
     run_loop_->Quit();
 
     EXPECT_EQ(expected_token_, tokens[0].token);
@@ skipping 39 matching lines @@
   EncodeTokenAndSaveSamples(false);
   DecodeSamplesAndVerifyToken(false);
   DetectBroadcast();
 }
 
 IN_PROC_BROWSER_TEST_F(ChromeWhispernetClientTest, Audible) {
   InitializeWhispernet();
   EncodeTokenAndSaveSamples(true);
   DecodeSamplesAndVerifyToken(true);
 }