Add audible support to the copresence API.

components/copresence/rpc/rpc_handler.cc

Index: components/copresence/rpc/rpc_handler.cc
diff --git a/components/copresence/rpc/rpc_handler.cc b/components/copresence/rpc/rpc_handler.cc
index bd16adf61922e43301562f1232acd21ad8f142e2..8773e15994292e30015d3e9936c95b8ef87f80ab 100644
--- a/components/copresence/rpc/rpc_handler.cc
+++ b/components/copresence/rpc/rpc_handler.cc
@@ -140,12 +140,32 @@ BroadcastScanConfiguration ExtractTokenExchangeStrategy(
   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);
+  if (ExtractIsAudibleStrategy(request))
+    token_technology->set_medium(AUDIO_AUDIBLE_DTMF);
 
   BroadcastScanConfiguration config =
       ExtractTokenExchangeStrategy(request);
@@ -198,12 +218,6 @@ RpcHandler::~RpcHandler() {
 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();
@@ -290,9 +304,9 @@ void RpcHandler::ConnectToWhispernet() {
 
 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;
@@ -315,14 +329,13 @@ void RpcHandler::RegisterResponseHandler(
   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;
@@ -445,11 +458,10 @@ RequestHeader* RpcHandler::CreateRequestHeader(
 }
 
 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,
@@ -460,7 +472,7 @@ void RpcHandler::SendServerRequest(
 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 =
@@ -469,20 +481,20 @@ void RpcHandler::SendHttpPost(net::URLRequestContextGetter* url_context_getter,
       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);
   }
 }