Two small bugfixes

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 <cmath>
 #include <cstdlib>
 #include <string>
 
@@ skipping 15 matching lines @@
 #include "media/base/audio_bus.h"
 #include "media/base/audio_converter.h"
 
 using audio_modem::WhispernetClient;
 using audio_modem::AUDIBLE;
 using audio_modem::INAUDIBLE;
 using audio_modem::TokenParameters;
 
 namespace {
 
-// TODO(rkc): Add more varied test input.
+// TODO(ckehoe): Use randomly generated tokens instead.
 const char kSixZeros[] = "MDAwMDAw";
 const char kEightZeros[] = "MDAwMDAwMDA";
 const char kNineZeros[] = "MDAwMDAwMDAw";
 
 const size_t kTokenLengths[2] = {6, 6};
 
 // Copied from src/components/copresence/mediums/audio/audio_recorder.cc
 std::string AudioBusToString(scoped_refptr<media::AudioBusRefCounted> source) {
   std::string buffer;
   buffer.resize(source->frames() * source->channels() * sizeof(float));
@@ skipping 60 matching lines @@
         media::AudioParameters::NO_EFFECTS);
 
     converter_.reset(new media::AudioConverter(
         coder_params_, default_params_,
         default_params_.sample_rate() == coder_params_.sample_rate()));
     converter_->AddInput(this);
   }
 
   void EncodeTokenAndSaveSamples(WhispernetClient* client,
                                  bool audible,
-                                 const std::string& token) {
+                                 const std::string& token,
+                                 const TokenParameters token_params[2]) {
     run_loop_.reset(new base::RunLoop());
     client->RegisterSamplesCallback(
         base::Bind(&ChromeWhispernetClientTest::SamplesCallback,
                    base::Unretained(this)));
     expected_token_ = token;
     expected_audible_ = audible;
 
-    TokenParameters token_params[2];
     client->EncodeToken(token, audible ? AUDIBLE : INAUDIBLE, token_params);
     run_loop_->Run();
 
     EXPECT_GT(saved_samples_->frames(), 0);
   }
 
   void DecodeSamplesAndVerifyToken(WhispernetClient* client,
                                    bool expect_audible,
                                    const std::string& expected_token,
                                    const TokenParameters token_params[2]) {
@@ skipping 93 matching lines @@
   media::AudioParameters coder_params_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeWhispernetClientTest);
 };
 
 // These tests are irrelevant if NACL is disabled. See crbug.com/449198
 #if defined(DISABLE_NACL)
 #define MAYBE_Initialize DISABLED_Initialize
 #define MAYBE_EncodeAndDecode DISABLED_EncodeAndDecode
 #define MAYBE_TokenLengths DISABLED_TokenLengths
+#define MAYBE_Crc DISABLED_Crc
 #define MAYBE_MultipleClients DISABLED_MultipleClients
 #else
 #define MAYBE_Initialize Initialize
 #define MAYBE_EncodeAndDecode EncodeAndDecode
 #define MAYBE_TokenLengths TokenLengths
+#define MAYBE_Crc Crc
 #define MAYBE_MultipleClients MultipleClients
 #endif
 
 IN_PROC_BROWSER_TEST_F(ChromeWhispernetClientTest, MAYBE_Initialize) {
   InitializeWhispernet();
 }
 
 IN_PROC_BROWSER_TEST_F(ChromeWhispernetClientTest, MAYBE_EncodeAndDecode) {
   scoped_ptr<WhispernetClient> client(
       new ChromeWhispernetClient(browser()->profile()));
   client->Initialize(base::Bind(&IgnoreResult));
   SetupDecode();
 
   TokenParameters token_params[2];
   GetTokenParamsForLengths(kTokenLengths, token_params);
 
-  EncodeTokenAndSaveSamples(client.get(), true, kSixZeros);
+  EncodeTokenAndSaveSamples(client.get(), true, kSixZeros, token_params);
   DecodeSamplesAndVerifyToken(client.get(), true, kSixZeros, token_params);
 
-  EncodeTokenAndSaveSamples(client.get(), false, kSixZeros);
+  EncodeTokenAndSaveSamples(client.get(), false, kSixZeros, token_params);
   DecodeSamplesAndVerifyToken(client.get(), false, kSixZeros, token_params);
 }
 
 IN_PROC_BROWSER_TEST_F(ChromeWhispernetClientTest, MAYBE_TokenLengths) {
   scoped_ptr<WhispernetClient> client(
       new ChromeWhispernetClient(browser()->profile()));
   client->Initialize(base::Bind(&IgnoreResult));
   SetupDecode();
 
   const size_t kLongTokenLengths[2] = {8, 9};
   TokenParameters token_params[2];
   GetTokenParamsForLengths(kLongTokenLengths, token_params);
 
-  EncodeTokenAndSaveSamples(client.get(), true, kEightZeros);
+  EncodeTokenAndSaveSamples(client.get(), true, kEightZeros, token_params);
   DecodeSamplesAndVerifyToken(client.get(), true, kEightZeros, token_params);
 
-  EncodeTokenAndSaveSamples(client.get(), false, kNineZeros);
+  EncodeTokenAndSaveSamples(client.get(), false, kNineZeros, token_params);
   DecodeSamplesAndVerifyToken(client.get(), false, kNineZeros, token_params);
 }
 
+IN_PROC_BROWSER_TEST_F(ChromeWhispernetClientTest, MAYBE_Crc) {
+  scoped_ptr<WhispernetClient> client(
+      new ChromeWhispernetClient(browser()->profile()));
+  client->Initialize(base::Bind(&IgnoreResult));
+  SetupDecode();
+
+  TokenParameters token_params[2];
+  GetTokenParamsForLengths(kTokenLengths, token_params);
+  token_params[0].crc = true;
+  token_params[1].crc = true;
+
+  EncodeTokenAndSaveSamples(client.get(), true, kSixZeros, token_params);
+  DecodeSamplesAndVerifyToken(client.get(), true, kSixZeros, token_params);
+
+  EncodeTokenAndSaveSamples(client.get(), false, kSixZeros, token_params);
+  DecodeSamplesAndVerifyToken(client.get(), false, kSixZeros, token_params);
+}
+
 IN_PROC_BROWSER_TEST_F(ChromeWhispernetClientTest, MAYBE_MultipleClients) {
   scoped_ptr<WhispernetClient> client_1(
       new ChromeWhispernetClient(browser()->profile()));
   scoped_ptr<WhispernetClient> client_2(
       new ChromeWhispernetClient(browser()->profile()));
   scoped_ptr<WhispernetClient> client_3(
       new ChromeWhispernetClient(browser()->profile()));
   SetupDecode();
 
   TokenParameters token_params[2];
   GetTokenParamsForLengths(kTokenLengths, token_params);
 
   // Test concurrent initialization.
   client_1->Initialize(base::Bind(&IgnoreResult));
   client_2->Initialize(base::Bind(&IgnoreResult));
 
-  EncodeTokenAndSaveSamples(client_1.get(), true, kSixZeros);
+  EncodeTokenAndSaveSamples(client_1.get(), true, kSixZeros, token_params);
   DecodeSamplesAndVerifyToken(client_1.get(), true, kSixZeros, token_params);
 
-  EncodeTokenAndSaveSamples(client_2.get(), false, kSixZeros);
+  EncodeTokenAndSaveSamples(client_2.get(), false, kSixZeros, token_params);
   DecodeSamplesAndVerifyToken(client_2.get(), false, kSixZeros, token_params);
 
   // Test sequential initialization.
   client_3->Initialize(base::Bind(&IgnoreResult));
 
-  EncodeTokenAndSaveSamples(client_3.get(), true, kSixZeros);
+  EncodeTokenAndSaveSamples(client_3.get(), true, kSixZeros, token_params);
   DecodeSamplesAndVerifyToken(client_3.get(), true, kSixZeros, token_params);
 
   const size_t kLongTokenLengths[2] = {8, 9};
   GetTokenParamsForLengths(kLongTokenLengths, token_params);
 
-  EncodeTokenAndSaveSamples(client_2.get(), true, kEightZeros);
+  EncodeTokenAndSaveSamples(client_2.get(), true, kEightZeros, token_params);
   DecodeSamplesAndVerifyToken(client_2.get(), true, kEightZeros, token_params);
 }
-
-// TODO(ckehoe): Test crc and parity
-// TODO(ckehoe): More multi-client testing