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

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/copresence/copresence_translations.h"
   6
   7 #include "chrome/common/extensions/api/copresence.h"
   8 #include "components/copresence/proto/data.pb.h"
   9 #include "components/copresence/proto/enums.pb.h"
  10 #include "components/copresence/proto/rpcs.pb.h"
  11
  12 using copresence::AUDIO_CONFIGURATION_AUDIBLE;
  13 using copresence::AUDIO_CONFIGURATION_UNKNOWN;
  14 using copresence::BROADCAST_AND_SCAN;
  15 using copresence::BROADCAST_ONLY;
  16 using copresence::BROADCAST_SCAN_CONFIGURATION_UNKNOWN;
  17 using copresence::BroadcastScanConfiguration;
  18 using copresence::ReportRequest;
  19 using copresence::SCAN_ONLY;
  20 using copresence::TokenExchangeStrategy;
  21
  22 using extensions::api::copresence::Strategy;
  23
  24 namespace {
  25
  26 const int kDefaultTimeToLiveMs = 5 * 60 * 1000;    // 5 minutes.
  27 const int kMaxTimeToLiveMs = 24 * 60 * 60 * 1000;  // 24 hours.
  28
  29 // Checks and returns the ttl provided by the user. If invalid, returns -1.
  30 int SanitizeTtl(int* user_ttl) {
  31   return !user_ttl
  32       ? kDefaultTimeToLiveMs
  33       : (*user_ttl <= 0 || *user_ttl > kMaxTimeToLiveMs ? -1 : *user_ttl);
  34 }
  35
  36 BroadcastScanConfiguration TranslateStrategy(const Strategy& strategy) {
  37   bool only_broadcast = strategy.only_broadcast && *strategy.only_broadcast;
  38   bool only_scan = strategy.only_scan && *strategy.only_scan;
  39
  40   if (only_broadcast && only_scan)
  41     return BROADCAST_AND_SCAN;
  42   if (only_broadcast)
  43     return BROADCAST_ONLY;
  44   if (only_scan)
  45     return SCAN_ONLY;
  46
  47   return BROADCAST_SCAN_CONFIGURATION_UNKNOWN;
  48 }
  49
  50 // The strategy may be null (unspecified), so we pass it as a pointer.
  51 void SetTokenExchangeStrategy(const Strategy* strategy,
  52                               BroadcastScanConfiguration default_config,
  53                               TokenExchangeStrategy* strategy_proto) {
  54   if (strategy) {
  55     BroadcastScanConfiguration config;
  56     if (strategy->low_power && *(strategy->low_power)) {
  57       config = BROADCAST_SCAN_CONFIGURATION_UNKNOWN;
  58     } else {
  59       config = TranslateStrategy(*strategy);
  60       if (config == BROADCAST_SCAN_CONFIGURATION_UNKNOWN)
  61         config = default_config;
  62     }
  63
  64     strategy_proto->set_broadcast_scan_configuration(config);
  65     strategy_proto->set_audio_configuration(
  66         strategy->audible && *strategy->audible ? AUDIO_CONFIGURATION_AUDIBLE
  67                                                 : AUDIO_CONFIGURATION_UNKNOWN);
  68   } else {
  69     strategy_proto->set_broadcast_scan_configuration(default_config);
  70     strategy_proto->set_audio_configuration(AUDIO_CONFIGURATION_UNKNOWN);
  71   }
  72 }
  73
  74 }  // namespace
  75
  76 namespace extensions {
  77
  78 using api::copresence::Operation;
  79
  80 // Adds a publish operation to the report request. Returns false if the
  81 // publish operation was invalid.
  82 bool AddPublishToRequest(const std::string& app_id,
  83                          const api::copresence::PublishOperation& publish,
  84                          ReportRequest* request) {
  85   copresence::PublishedMessage* publish_proto =
  86       request->mutable_manage_messages_request()->add_message_to_publish();
  87   publish_proto->mutable_access_policy()->mutable_acl()->set_acl_type(
  88       copresence::NO_ACL_CHECK);
  89   publish_proto->set_id(publish.id);
  90   publish_proto->mutable_message()->mutable_type()->set_type(
  91       publish.message.type);
  92   publish_proto->mutable_message()->set_payload(publish.message.payload);
  93
  94   int ttl = SanitizeTtl(publish.time_to_live_millis.get());
  95   if (ttl < 0)
  96     return false;
  97   publish_proto->mutable_access_policy()->set_ttl_millis(ttl);
  98
  99   SetTokenExchangeStrategy(publish.strategies.get(),
 100                            BROADCAST_ONLY,
 101                            publish_proto->mutable_token_exchange_strategy());
 102
 103   DVLOG(2) << "Publishing message of type " << publish.message.type << ":\n"
 104            << publish.message.payload;
 105   // TODO(ckehoe): Validate that required fields are non-empty, etc.
 106   return true;
 107 }
 108
 109 // Adds an unpublish operation to the report request. Returns false if the
 110 // publish id was invalid.
 111 bool AddUnpublishToRequest(const std::string& publish_id,
 112                            ReportRequest* request) {
 113   if (publish_id.empty())
 114     return false;
 115
 116   request->mutable_manage_messages_request()->add_id_to_unpublish(publish_id);
 117   DVLOG(2) << "Unpublishing message \"" << publish_id << "\"";
 118   return true;
 119 }
 120
 121 // Adds a subscribe operation to the report request. Returns false if the
 122 // subscription operation was invalid.
 123 bool AddSubscribeToRequest(
 124     const std::string& app_id,
 125     const api::copresence::SubscribeOperation& subscription,
 126     SubscriptionToAppMap* apps_by_subscription_id,
 127     ReportRequest* request) {
 128   // Associate the subscription id with the app id.
 129   SubscriptionToAppMap::iterator previous_subscription =
 130       apps_by_subscription_id->find(subscription.id);
 131   if (previous_subscription == apps_by_subscription_id->end()) {
 132     (*apps_by_subscription_id)[subscription.id] = app_id;
 133   } else if (previous_subscription->second == app_id) {
 134     VLOG(2) << "Overwriting subscription id \"" << subscription.id
 135             << "\" for app \"" << app_id << "\"";
 136   } else {
 137     // A conflicting association exists already.
 138     VLOG(1) << "Subscription id \"" << subscription.id
 139             << "\" used by two apps: \"" << previous_subscription->second
 140             << "\" and \"" << app_id << "\"";
 141     return false;
 142   }
 143
 144   // Convert from IDL to server subscription format.
 145   copresence::Subscription* subscription_proto =
 146       request->mutable_manage_subscriptions_request()->add_subscription();
 147   subscription_proto->set_id(subscription.id);
 148   int ttl = SanitizeTtl(subscription.time_to_live_millis.get());
 149   if (ttl < 0)
 150     return false;
 151   subscription_proto->set_ttl_millis(ttl);
 152
 153   subscription_proto->mutable_message_type()->set_type(
 154       subscription.filter.type);
 155
 156   SetTokenExchangeStrategy(
 157       subscription.strategies.get(),
 158       SCAN_ONLY,
 159       subscription_proto->mutable_token_exchange_strategy());
 160
 161   DVLOG(2) << "Subscribing for messages of type " << subscription.filter.type;
 162   // TODO(ckehoe): Validate that required fields are non-empty, etc.
 163   return true;
 164 }
 165
 166 // Adds an unpublish operation to the report request. Returns false if the
 167 // subscription id was invalid.
 168 bool AddUnsubscribeToRequest(const std::string& app_id,
 169                              const std::string& subscription_id,
 170                              SubscriptionToAppMap* apps_by_subscription_id,
 171                              ReportRequest* request) {
 172   if (subscription_id.empty())
 173     return false;
 174
 175   // Check that this subscription id belongs to this app.
 176   SubscriptionToAppMap::iterator subscription =
 177       apps_by_subscription_id->find(subscription_id);
 178   if (subscription == apps_by_subscription_id->end()) {
 179     LOG(ERROR) << "No such subscription \"" << subscription_id
 180                << "\". Cannot unsubscribe.";
 181     return false;
 182   } else if (subscription->second != app_id) {
 183     LOG(ERROR) << "Subscription \"" << subscription_id
 184                << "\" does not belong to app \"" << app_id
 185                << "\". Cannot unsubscribe.";
 186     return false;
 187   } else {
 188     apps_by_subscription_id->erase(subscription);
 189   }
 190
 191   request->mutable_manage_subscriptions_request()->add_id_to_unsubscribe(
 192       subscription_id);
 193   DVLOG(2) << "Cancelling subscription \"" << subscription_id << "\" for app \""
 194            << app_id << "\"";
 195   return true;
 196 }
 197
 198 bool PrepareReportRequestProto(
 199     const std::vector<linked_ptr<Operation>>& operations,
 200     const std::string& app_id,
 201     SubscriptionToAppMap* apps_by_subscription_id,
 202     ReportRequest* request) {
 203   for (size_t i = 0; i < operations.size(); ++i) {
 204     linked_ptr<Operation> op = operations[i];
 205     DCHECK(op.get());
 206
 207     // Verify our object has exactly one operation.
 208     if (static_cast<int>(op->publish != NULL) +
 209         static_cast<int>(op->subscribe != NULL) +
 210         static_cast<int>(op->unpublish != NULL) +
 211         static_cast<int>(op->unsubscribe != NULL) != 1) {
 212       return false;
 213     }
 214
 215     if (op->publish) {
 216       if (!AddPublishToRequest(app_id, *(op->publish), request))
 217         return false;
 218     } else if (op->subscribe) {
 219       if (!AddSubscribeToRequest(
 220               app_id, *(op->subscribe), apps_by_subscription_id, request))
 221         return false;
 222     } else if (op->unpublish) {
 223       if (!AddUnpublishToRequest(op->unpublish->unpublish_id, request))
 224         return false;
 225     } else {  // if (op->unsubscribe)
 226       if (!AddUnsubscribeToRequest(app_id,
 227                                    op->unsubscribe->unsubscribe_id,
 228                                    apps_by_subscription_id,
 229                                    request))
 230         return false;
 231     }
 232   }
 233
 234   return true;
 235 }
 236
 237 }  // namespace extensions