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