Setting AudioConfiguration and deleting DeviceCapabilities hacks

Review URL: https://codereview.chromium.org/600843004

Cr-Commit-Position: refs/heads/master@{#297019}

chrome/browser/extensions/api/copresence/copresence_api_unittest.cc

@@ -12,6 +12,8 @@
 #include "components/copresence/public/copresence_manager.h"
 
 using base::ListValue;
+using copresence::AUDIBLE;
+using copresence::AUDIO_CONFIGURATION_UNKNOWN;
 using copresence::BROADCAST_ONLY;
 using copresence::CopresenceDelegate;
 using copresence::CopresenceManager;
@@ -164,12 +166,15 @@ TEST_F(CopresenceApiUnittest, Publish) {
   EXPECT_EQ("Knock Knock!", message.message().payload());
   EXPECT_EQ(BROADCAST_ONLY,
             message.token_exchange_strategy().broadcast_scan_configuration());
+  EXPECT_EQ(AUDIO_CONFIGURATION_UNKNOWN,
+            message.token_exchange_strategy().audio_configuration());
 }
 
 TEST_F(CopresenceApiUnittest, Subscribe) {
   scoped_ptr<SubscribeOperation> subscribe(CreateSubscribe("sub"));
   subscribe->strategies.reset(new Strategy);
   subscribe->strategies->only_broadcast.reset(new bool(true));  // Not default
+  subscribe->strategies->audible.reset(new bool(true)); // Not default
 
   scoped_ptr<Operation> operation(new Operation);
   operation->subscribe = subscribe.Pass();
@@ -185,9 +190,11 @@ TEST_F(CopresenceApiUnittest, Subscribe) {
   EXPECT_EQ("sub", subscription.id());
   EXPECT_EQ(1000, subscription.ttl_millis());
   EXPECT_EQ("joke", subscription.message_type().type());
-  copresence::BroadcastScanConfiguration strategy =
+  copresence::BroadcastScanConfiguration broadcast_scan =
       subscription.token_exchange_strategy().broadcast_scan_configuration();
-  EXPECT_EQ(BROADCAST_ONLY, strategy);
+  EXPECT_EQ(BROADCAST_ONLY, broadcast_scan);
+  EXPECT_EQ(AUDIBLE,
+            subscription.token_exchange_strategy().audio_configuration());
 }
 
 TEST_F(CopresenceApiUnittest, DefaultStrategies) {

chrome/browser/extensions/api/copresence/copresence_translations.cc

@@ -9,6 +9,8 @@
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
 
+using copresence::AUDIBLE;
+using copresence::AUDIO_CONFIGURATION_UNKNOWN;
 using copresence::BROADCAST_AND_SCAN;
 using copresence::BROADCAST_ONLY;
 using copresence::BROADCAST_SCAN_CONFIGURATION_UNKNOWN;
@@ -54,9 +56,12 @@ void SetTokenExchangeStrategy(const Strategy* strategy,
     strategy_proto->set_broadcast_scan_configuration(
         config == BROADCAST_SCAN_CONFIGURATION_UNKNOWN ?
         default_config : config);
-    strategy_proto->set_use_audible(strategy->audible && *strategy->audible);
+    strategy_proto->set_audio_configuration(
+        strategy->audible && *strategy->audible ?
+        AUDIBLE : AUDIO_CONFIGURATION_UNKNOWN);
   } else {
     strategy_proto->set_broadcast_scan_configuration(default_config);
+    strategy_proto->set_audio_configuration(AUDIO_CONFIGURATION_UNKNOWN);
   }
 }
 

components/copresence/proto/data.proto

@@ -92,10 +92,6 @@ message PublishedMessage {
 message TokenExchangeStrategy {
   optional AudioConfiguration audio_configuration = 1;
   optional BroadcastScanConfiguration broadcast_scan_configuration = 2;
-  // TODO(rkc): Horrible hack. Get rid of this once the server tells us whether
-  // or not to use audible for a given publish or subscribe.
-  // http://b/16849245/
-  optional bool use_audible = 99;
 }
 message SubscribedMessage {
   message Debug {

components/copresence/rpc/rpc_handler.cc

@@ -103,85 +103,20 @@ BroadcastScanConfiguration GetBroadcastScanConfig(const T& msg) {
   return BROADCAST_SCAN_CONFIGURATION_UNKNOWN;
 }
 
-// This method will extract token exchange strategies
-// from the publishes and subscribes in a report request.
-// TODO(ckehoe): Delete this when the server supports
-// BroadcastScanConfiguration.
-BroadcastScanConfiguration ExtractTokenExchangeStrategy(
-    const ReportRequest& request) {
-  bool broadcast_only = false;
-  bool scan_only = false;
-
-  // Strategies for publishes.
-  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) {
-      BroadcastScanConfiguration config =
-          GetBroadcastScanConfig(messages.Get(i));
-      broadcast_only = broadcast_only || config == BROADCAST_ONLY;
-      scan_only = scan_only || config == SCAN_ONLY;
-      if (config == BROADCAST_AND_SCAN || (broadcast_only && scan_only))
-        return BROADCAST_AND_SCAN;
-    }
-  }
-
-  // Strategies for subscriptions.
-  if (request.has_manage_subscriptions_request()) {
-    const RepeatedPtrField<Subscription> subscriptions =
-        request.manage_subscriptions_request().subscription();
-    for (int i = 0; i < subscriptions.size(); ++i) {
-      BroadcastScanConfiguration config =
-          GetBroadcastScanConfig(subscriptions.Get(i));
-      broadcast_only = broadcast_only || config == BROADCAST_ONLY;
-      scan_only = scan_only || config == SCAN_ONLY;
-      if (config == BROADCAST_AND_SCAN || (broadcast_only && scan_only))
-        return BROADCAST_AND_SCAN;
-    }
-  }
-
-  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 =
+  TokenTechnology* ultrasound =
       state->mutable_capabilities()->add_token_technology();
-  token_technology->set_medium(AUDIO_ULTRASOUND_PASSBAND);
-  if (ExtractIsAudibleStrategy(request))
-    token_technology->set_medium(AUDIO_AUDIBLE_DTMF);
+  ultrasound->set_medium(AUDIO_ULTRASOUND_PASSBAND);
+  ultrasound->add_instruction_type(TRANSMIT);
+  ultrasound->add_instruction_type(RECEIVE);
 
-  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);
+  TokenTechnology* audible =
+      state->mutable_capabilities()->add_token_technology();
+  audible->set_medium(AUDIO_AUDIBLE_DTMF);
+  audible->add_instruction_type(TRANSMIT);
+  audible->add_instruction_type(RECEIVE);
 
   return state.Pass();
 }
@@ -277,25 +212,6 @@ void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request,
 
   AddPlayingTokens(request.get());
 
-  // TODO(ckehoe): Currently the server supports only BROADCAST_AND_SCAN.
-  // Remove this once b/16715253 is fixed.
-  if (request->has_manage_messages_request()) {
-    RepeatedPtrField<PublishedMessage>* messages = request
-        ->mutable_manage_messages_request()->mutable_message_to_publish();
-    for (int i = 0; i < messages->size(); ++i) {
-      messages->Mutable(i)->mutable_token_exchange_strategy()
-          ->set_broadcast_scan_configuration(BROADCAST_AND_SCAN);
-    }
-  }
-  if (request->has_manage_subscriptions_request()) {
-    RepeatedPtrField<Subscription>* subscriptions =
-        request->mutable_manage_subscriptions_request()->mutable_subscription();
-    for (int i = 0; i < subscriptions->size(); ++i) {
-      subscriptions->Mutable(i)->mutable_token_exchange_strategy()
-          ->set_broadcast_scan_configuration(BROADCAST_AND_SCAN);
-    }
-  }
-
   SendServerRequest(kReportRequestRpcName,
                     app_id,
                     request.Pass(),

components/copresence/rpc/rpc_handler_unittest.cc

@@ -27,20 +27,6 @@ namespace {
 
 const char kChromeVersion[] = "Chrome Version String";
 
-void AddMessageWithStrategy(ReportRequest* report,
-                            BroadcastScanConfiguration strategy) {
-  report->mutable_manage_messages_request()->add_message_to_publish()
-      ->mutable_token_exchange_strategy()->set_broadcast_scan_configuration(
-          strategy);
-}
-
-void AddSubscriptionWithStrategy(ReportRequest* report,
-                                 BroadcastScanConfiguration strategy) {
-  report->mutable_manage_subscriptions_request()->add_subscription()
-      ->mutable_token_exchange_strategy()->set_broadcast_scan_configuration(
-          strategy);
-}
-
 void CreateSubscribedMessage(const std::vector<std::string>& subscription_ids,
                              const std::string& message_string,
                              SubscribedMessage* message_proto) {
@@ -201,54 +187,6 @@ TEST_F(RpcHandlerTest, Initialize) {
   EXPECT_FALSE(identity.chrome_id().empty());
 }
 
-TEST_F(RpcHandlerTest, GetDeviceCapabilities) {
-  // Empty request.
-  rpc_handler_.SendReportRequest(make_scoped_ptr(new ReportRequest));
-  EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
-  const TokenTechnology* token_technology = &GetTokenTechnologyFromReport();
-  EXPECT_EQ(AUDIO_ULTRASOUND_PASSBAND, token_technology->medium());
-  EXPECT_EQ(TRANSMIT, token_technology->instruction_type(0));
-  EXPECT_EQ(RECEIVE, token_technology->instruction_type(1));
-
-  // Request with broadcast only.
-  scoped_ptr<ReportRequest> report(new ReportRequest);
-  AddMessageWithStrategy(report.get(), BROADCAST_ONLY);
-  rpc_handler_.SendReportRequest(report.Pass());
-  token_technology = &GetTokenTechnologyFromReport();
-  EXPECT_EQ(1, token_technology->instruction_type_size());
-  EXPECT_EQ(TRANSMIT, token_technology->instruction_type(0));
-  EXPECT_FALSE(GetReportSent()->has_manage_subscriptions_request());
-
-  // Request with scan only.
-  report.reset(new ReportRequest);
-  AddSubscriptionWithStrategy(report.get(), SCAN_ONLY);
-  AddSubscriptionWithStrategy(report.get(), SCAN_ONLY);
-  rpc_handler_.SendReportRequest(report.Pass());
-  token_technology = &GetTokenTechnologyFromReport();
-  EXPECT_EQ(1, token_technology->instruction_type_size());
-  EXPECT_EQ(RECEIVE, token_technology->instruction_type(0));
-  EXPECT_FALSE(GetReportSent()->has_manage_messages_request());
-
-  // Request with both scan and broadcast only (conflict).
-  report.reset(new ReportRequest);
-  AddMessageWithStrategy(report.get(), SCAN_ONLY);
-  AddMessageWithStrategy(report.get(), BROADCAST_ONLY);
-  AddSubscriptionWithStrategy(report.get(), BROADCAST_ONLY);
-  rpc_handler_.SendReportRequest(report.Pass());
-  token_technology = &GetTokenTechnologyFromReport();
-  EXPECT_EQ(TRANSMIT, token_technology->instruction_type(0));
-  EXPECT_EQ(RECEIVE, token_technology->instruction_type(1));
-
-  // Request with broadcast and scan.
-  report.reset(new ReportRequest);
-  AddMessageWithStrategy(report.get(), SCAN_ONLY);
-  AddSubscriptionWithStrategy(report.get(), BROADCAST_AND_SCAN);
-  rpc_handler_.SendReportRequest(report.Pass());
-  token_technology = &GetTokenTechnologyFromReport();
-  EXPECT_EQ(TRANSMIT, token_technology->instruction_type(0));
-  EXPECT_EQ(RECEIVE, token_technology->instruction_type(1));
-}
-
 TEST_F(RpcHandlerTest, CreateRequestHeader) {
   SetDeviceId("CreateRequestHeader Device ID");
   rpc_handler_.SendReportRequest(make_scoped_ptr(new ReportRequest),