Improve audible token detection.

components/copresence/rpc/rpc_handler.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 "components/copresence/rpc/rpc_handler.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 244 matching lines @@
       GetDeviceCapabilities(*request).release());
   SendServerRequest(kReportRequestRpcName,
                     app_id,
                     request.Pass(),
                     // On destruction, this request will be cancelled.
                     base::Bind(&RpcHandler::ReportResponseHandler,
                                base::Unretained(this),
                                status_callback));
 }
 
-void RpcHandler::ReportTokens(TokenMedium medium,
-                              const std::vector<std::string>& tokens) {
-  DCHECK_EQ(medium, AUDIO_ULTRASOUND_PASSBAND);
+void RpcHandler::ReportTokens(const std::vector<FullToken>& tokens) {
   DCHECK(!tokens.empty());
 
   scoped_ptr<ReportRequest> request(new ReportRequest);
   for (size_t i = 0; i < tokens.size(); ++i) {
-    const std::string& token = ToUrlSafe(tokens[i]);
+    const std::string& token = ToUrlSafe(tokens[i].token);
     if (invalid_audio_token_cache_.HasKey(token))
       continue;
 
     DVLOG(3) << "Sending token " << token << " to server.";
 
     TokenObservation* token_observation =
         request->mutable_update_signals_request()->add_token_observation();
     token_observation->set_token_id(token);
 
     TokenSignals* signals = token_observation->add_signals();
-    signals->set_medium(medium);
+    signals->set_medium(tokens[i].audible ? AUDIO_AUDIBLE_DTMF
+                                          : AUDIO_ULTRASOUND_PASSBAND);
     signals->set_observed_time_millis(base::Time::Now().ToJsTime());
   }
   SendReportRequest(request.Pass());
 }
 
 void RpcHandler::ConnectToWhispernet() {
   WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
 
   // |directive_handler_| will be destructed with us, so unretained is safe.
   directive_handler_.reset(new DirectiveHandler);
   directive_handler_->Initialize(
       base::Bind(&WhispernetClient::DecodeSamples,
                  base::Unretained(whispernet_client)),
       base::Bind(&RpcHandler::AudioDirectiveListToWhispernetConnector,
                  base::Unretained(this)));
 
   whispernet_client->RegisterTokensCallback(
       base::Bind(&RpcHandler::ReportTokens,
                  // On destruction, this callback will be disconnected.
-                 base::Unretained(this),
-                 AUDIO_ULTRASOUND_PASSBAND));
+                 base::Unretained(this)));
 }
 
 // Private methods
 
 void RpcHandler::RegisterResponseHandler(
     const SuccessCallback& init_done_callback,
     HttpPost* completed_post,
     int http_status_code,
     const std::string& response_data) {
   if (completed_post) {
@@ skipping 187 matching lines @@
     bool audible,
     const WhispernetClient::SamplesCallback& samples_callback) {
   WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
   if (whispernet_client) {
     whispernet_client->RegisterSamplesCallback(samples_callback);
     whispernet_client->EncodeToken(token, audible);
   }
 }
 
 }  // namespace copresence