Setting OptInStateFilter for publishes and subscribes (b/16324352)

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 101 matching lines @@
           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> messages =
+    const RepeatedPtrField<Subscription> subscriptions =
         request.manage_subscriptions_request().subscription();
-    for (int i = 0; i < messages.size(); ++i) {
+    for (int i = 0; i < subscriptions.size(); ++i) {
       BroadcastScanConfiguration config =
-          GetBroadcastScanConfig(messages.Get(i));
+          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)
@@ skipping 50 matching lines @@
 ClientVersion* CreateVersion(const std::string& client,
                              const std::string& version_name) {
   ClientVersion* version = new ClientVersion;
 
   version->set_client(client);
   version->set_version_name(version_name);
 
   return version;
 }
 
+OptInStateFilter* CreateOptedInOrOutFilter() {
+  OptInStateFilter* filter = new OptInStateFilter;
+  filter->add_allowed_opt_in_state(copresence::OPTED_IN);
+  filter->add_allowed_opt_in_state(copresence::OPTED_OUT);
+  return filter;
+}
+
+void AllowOptedOutMessages(ReportRequest* request) {

[rkc, 2014/08/12 03:38:19]

This anonymous namespace is getting huge. We should move these functions out to
a copresence::proto_util namespace in a separate file.

[Charlie, 2014/08/12 04:36:14]

Added a TODO. Keep in mind that ExtractTokenExchangeStrategy will get deleted as
soon as the server supports the BroadcastScanConfiguration correctly.

+  RepeatedPtrField<PublishedMessage>* messages =

[rkc, 2014/08/12 03:38:19]

This is a pattern that we'll be following 3 places in the code once
https://codereview.chromium.org/461803003/ lands.

We should have a ProcessPublishes and ProcessSubscribes method which takes a
function pointer as a parameter. These methods would call that function on each
of the publishes/subscribes. 

I don't have time to fix this in my CL, but unless this fix is urgent to get
into M-38, let's fix it here.

[Charlie, 2014/08/12 04:36:14]

Another TODO. I think Ben probably doesn't want to wait until November for this
fix to go live.

Let's discuss this a bit offline. I believe RepeatedPtrField is designed to
cooperate with C++11 foreach syntax, so this problem could go away soon on its
own.

+      request->mutable_manage_messages_request()->mutable_message_to_publish();
+  for (int i = 0; i < messages->size(); ++i) {
+    PublishedMessage* message = messages->Mutable(i);
+    if (!message->has_opt_in_state_filter())
+      message->set_allocated_opt_in_state_filter(CreateOptedInOrOutFilter());
+  }
+
+  RepeatedPtrField<Subscription>* subscriptions =
+        request->mutable_manage_subscriptions_request()->mutable_subscription();
+  for (int i = 0; i < subscriptions->size(); ++i) {
+    Subscription* subscription = subscriptions->Mutable(i);
+    if (!subscription->has_opt_in_state_filter()) {
+      subscription->set_allocated_opt_in_state_filter(
+          CreateOptedInOrOutFilter());
+    }
+  }
+}
+
 }  // namespace
 
 // Public methods
 
 RpcHandler::RpcHandler(CopresenceClientDelegate* delegate)
     : delegate_(delegate),
       invalid_audio_token_cache_(
           base::TimeDelta::FromMilliseconds(kInvalidTokenExpiryTimeMs),
           kMaxInvalidTokens),
       server_post_callback_(base::Bind(&RpcHandler::SendHttpPost,
@@ skipping 39 matching lines @@
                                    const StatusCallback& status_callback) {
   DCHECK(request.get());
   DCHECK(!device_id_.empty())
       << "RpcHandler::Initialize() must complete successfully "
       << "before other RpcHandler methods are called.";
 
   DVLOG(3) << "Sending report request to server.";
 
   request->mutable_update_signals_request()->set_allocated_state(
       GetDeviceCapabilities(*request).release());
+  AllowOptedOutMessages(request.get());
   SendServerRequest(kReportRequestRpcName,
                     app_id,
                     request.Pass(),
                     // On destruction, this request will be cancelled.
                     base::Bind(&RpcHandler::ReportResponseHandler,
                                base::Unretained(this),
                                status_callback));
 }
 
 void RpcHandler::ReportTokens(const std::vector<FullToken>& tokens) {
@@ skipping 234 matching lines @@
     bool audible,
     const WhispernetClient::SamplesCallback& samples_callback) {
   WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
   if (whispernet_client) {
     whispernet_client->RegisterSamplesCallback(samples_callback);
     whispernet_client->EncodeToken(token, audible);
   }
 }
 
 }  // namespace copresence