Add audible support to the copresence API.

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 122 matching lines @@
 
   if (broadcast_only)
     return BROADCAST_ONLY;
   if (scan_only)
     return SCAN_ONLY;
 
   // If nothing else is specified, default to both broadcast and scan.
   return BROADCAST_AND_SCAN;
 }
 
+// TODO(rkc): Fix this hack once the server supports setting strategies per
+// operation.
+bool ExtractIsAudibleStrategy(const ReportRequest& request) {
+  if (request.has_manage_messages_request()) {
+    const RepeatedPtrField<PublishedMessage> messages =
+        request.manage_messages_request().message_to_publish();
+    for (int i = 0; i < messages.size(); ++i) {
+      const PublishedMessage& msg = messages.Get(i);
+      if (msg.has_token_exchange_strategy() &&
+          msg.token_exchange_strategy().has_use_audible() &&
+          msg.token_exchange_strategy().use_audible()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 scoped_ptr<DeviceState> GetDeviceCapabilities(const ReportRequest& request) {
   scoped_ptr<DeviceState> state(new DeviceState);
 
   TokenTechnology* token_technology =
       state->mutable_capabilities()->add_token_technology();
   token_technology->set_medium(AUDIO_ULTRASOUND_PASSBAND);

[Charlie, 2014/08/08 22:24:15]

token_technology->set_medium(ExtractIsAudibleStrategy(request) ?
    AUDIO_AUDIBLE_DTMF : AUDIO_ULTRASOUND_PASSBAND);

[rkc, 2014/08/09 06:58:54]

We set audible in addition to ultrasound, not instead of it.

+  if (ExtractIsAudibleStrategy(request))
+    token_technology->set_medium(AUDIO_AUDIBLE_DTMF);
 
   BroadcastScanConfiguration config =
       ExtractTokenExchangeStrategy(request);
   if (config == BROADCAST_ONLY || config == BROADCAST_AND_SCAN)
     token_technology->add_instruction_type(TRANSMIT);
   if (config == SCAN_ONLY || config == BROADCAST_AND_SCAN)
     token_technology->add_instruction_type(RECEIVE);
 
   return state.Pass();
 }
@@ skipping 32 matching lines @@
 
   if (delegate_ && delegate_->GetWhispernetClient()) {
     delegate_->GetWhispernetClient()->RegisterTokensCallback(
         WhispernetClient::TokensCallback());
   }
 }
 
 void RpcHandler::Initialize(const SuccessCallback& init_done_callback) {
   scoped_ptr<RegisterDeviceRequest> request(new RegisterDeviceRequest);
   DCHECK(device_id_.empty());
-  device_id_ = delegate_->GetDeviceId();
-  if (!device_id_.empty()) {
-    init_done_callback.Run(true);
-    return;
-  }
-
   request->mutable_push_service()->set_service(PUSH_SERVICE_NONE);
   Identity* identity =
       request->mutable_device_identifiers()->mutable_registrant();
   identity->set_type(CHROME);
   identity->set_chrome_id(base::GenerateGUID());
   SendServerRequest(
       kRegisterDeviceRpcName,
       std::string(),
       request.Pass(),
       base::Bind(&RpcHandler::RegisterResponseHandler,
@@ skipping 66 matching lines @@
       base::Bind(&RpcHandler::ReportTokens,
                  // On destruction, this callback will be disconnected.
                  base::Unretained(this),
                  AUDIO_ULTRASOUND_PASSBAND));
 }
 
 // Private methods
 
 void RpcHandler::RegisterResponseHandler(
     const SuccessCallback& init_done_callback,
+    HttpPost* completed_post,
     int http_status_code,
-    const std::string& response_data,
-    HttpPost* completed_post) {
+    const std::string& response_data) {
   if (completed_post) {
     DCHECK(pending_posts_.erase(completed_post));
     delete completed_post;
   }
 
   if (http_status_code != net::HTTP_OK) {
     init_done_callback.Run(false);
     return;
   }
 
   RegisterDeviceResponse response;
   if (!response.ParseFromString(response_data)) {
     LOG(ERROR) << "Invalid RegisterDeviceResponse:\n" << response_data;
     init_done_callback.Run(false);
     return;
   }
 
   if (CopresenceErrorLogged(response.header().status()))
     return;
   device_id_ = response.registered_device_id();
   DCHECK(!device_id_.empty());
   DVLOG(2) << "Device registration successful: id " << device_id_;
-  delegate_->SaveDeviceId(device_id_);
   init_done_callback.Run(true);
 }
 
 void RpcHandler::ReportResponseHandler(const StatusCallback& status_callback,
+                                       HttpPost* completed_post,
                                        int http_status_code,
-                                       const std::string& response_data,
-                                       HttpPost* completed_post) {
+                                       const std::string& response_data) {
   if (completed_post) {
     DCHECK(pending_posts_.erase(completed_post));
     delete completed_post;
   }
 
   if (http_status_code != net::HTTP_OK) {
     if (!status_callback.is_null())
       status_callback.Run(FAIL);
     return;
   }
@@ skipping 102 matching lines @@
     header->set_allocated_client_version(
         CreateVersion(client_name, std::string()));
   }
   header->set_current_time_millis(base::Time::Now().ToJsTime());
   header->set_registered_device_id(device_id_);
 
   return header;
 }
 
 template <class T>
-void RpcHandler::SendServerRequest(
-    const std::string& rpc_name,
-    const std::string& app_id,
-    scoped_ptr<T> request,
-    const HttpPost::ResponseCallback& response_handler) {
+void RpcHandler::SendServerRequest(const std::string& rpc_name,
+                                   const std::string& app_id,
+                                   scoped_ptr<T> request,
+                                   const PostCallback& response_handler) {
   request->set_allocated_header(CreateRequestHeader(app_id));
   server_post_callback_.Run(delegate_->GetRequestContext(),
                             rpc_name,
                             make_scoped_ptr<MessageLite>(request.release()),
                             response_handler);
 }
 
 void RpcHandler::SendHttpPost(net::URLRequestContextGetter* url_context_getter,
                               const std::string& rpc_name,
                               scoped_ptr<MessageLite> request_proto,
-                              const HttpPost::ResponseCallback& callback) {
+                              const PostCallback& callback) {
   // Create the base URL to call.
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   const std::string copresence_server_host =
       command_line->HasSwitch(switches::kCopresenceServer) ?
       command_line->GetSwitchValueASCII(switches::kCopresenceServer) :
       kDefaultCopresenceServer;
 
   // Create the request and keep a pointer until it completes.
-  pending_posts_.insert(new HttpPost(url_context_getter,
-                                     copresence_server_host,
-                                     rpc_name,
-                                     *request_proto,
-                                     callback));
+  HttpPost* post = new HttpPost(
+      url_context_getter, copresence_server_host, rpc_name, *request_proto);
+  pending_posts_.insert(post);
+  post->Start(base::Bind(callback, post));
 }
 
 void RpcHandler::AudioDirectiveListToWhispernetConnector(
     const std::string& token,
+    bool audible,
     const WhispernetClient::SamplesCallback& samples_callback) {
   WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
   if (whispernet_client) {
     whispernet_client->RegisterSamplesCallback(samples_callback);
-    whispernet_client->EncodeToken(token);
+    whispernet_client->EncodeToken(token, audible);
   }
 }
 
 }  // namespace copresence