Stop playing/recording when not needed.

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 87 matching lines @@
 // 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 =
+    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> messages =
+    const RepeatedPtrField<Subscription>& messages =
         request.manage_subscriptions_request().subscription();
     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;
     }
   }
@@ skipping 54 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;
 }
 
+void AddTokenToRequest(ReportRequest* request, const AudioToken& token) {
+  TokenObservation* token_observation =
+      request->mutable_update_signals_request()->add_token_observation();
+  token_observation->set_token_id(ToUrlSafe(token.token));
+
+  TokenSignals* signals = token_observation->add_signals();
+  signals->set_medium(token.audible ? AUDIO_AUDIBLE_DTMF
+                                    : AUDIO_ULTRASOUND_PASSBAND);
+  signals->set_observed_time_millis(base::Time::Now().ToJsTime());
+}
+
 }  // 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 37 matching lines @@
 void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request,
                                    const std::string& app_id,
                                    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.";
 
+  // If we are unpublishing or unsubscribing, we need to stop those publish or
+  // subscribes right away, we don't need to wait for the server to tell us.
+  ProcessRemovedOperations(*request);
+
   request->mutable_update_signals_request()->set_allocated_state(
       GetDeviceCapabilities(*request).release());
+
+  AddPlayingTokens(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) {
+void RpcHandler::ReportTokens(const std::vector<AudioToken>& tokens) {
   DCHECK(!tokens.empty());
 
   scoped_ptr<ReportRequest> request(new ReportRequest);
   for (size_t i = 0; i < tokens.size(); ++i) {
-    const std::string& token = ToUrlSafe(tokens[i].token);
-    if (invalid_audio_token_cache_.HasKey(token))
+    if (invalid_audio_token_cache_.HasKey(ToUrlSafe(tokens[i].token)))
       continue;
-
-    DVLOG(3) << "Sending token " << token << " to server.";
-
-    TokenObservation* token_observation =
-        request->mutable_update_signals_request()->add_token_observation();
-    token_observation->set_token_id(token);
-
-    TokenSignals* signals = token_observation->add_signals();
-    signals->set_medium(tokens[i].audible ? AUDIO_AUDIBLE_DTMF
-                                          : AUDIO_ULTRASOUND_PASSBAND);
-    signals->set_observed_time_millis(base::Time::Now().ToJsTime());
+    DVLOG(3) << "Sending token " << tokens[i].token << " to server.";
+    AddTokenToRequest(request.get(), tokens[i]);
   }
   SendReportRequest(request.Pass());
 }
 
 void RpcHandler::ConnectToWhispernet() {
   WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
 
   // |directive_handler_| will be destructed with us, so unretained is safe.
   directive_handler_.reset(new DirectiveHandler);
   directive_handler_->Initialize(
@@ skipping 114 matching lines @@
                    << tokens.Get(i).status();
       }
     }
   }
 
   // TODO(ckehoe): Return a more detailed status response.
   if (!status_callback.is_null())
     status_callback.Run(SUCCESS);
 }
 
+void RpcHandler::ProcessRemovedOperations(const ReportRequest& request) {
+  // Remove unpublishes.
+  if (request.has_manage_messages_request()) {
+    const RepeatedPtrField<std::string>& unpublishes =
+        request.manage_messages_request().id_to_unpublish();
+    for (int i = 0; i < unpublishes.size(); ++i)
+      directive_handler_->RemoveDirectives(unpublishes.Get(i));
+  }
+
+  // Remove unsubscribes.
+  if (request.has_manage_subscriptions_request()) {
+    const RepeatedPtrField<std::string>& unsubscribes =
+        request.manage_subscriptions_request().id_to_unsubscribe();
+    for (int i = 0; i < unsubscribes.size(); ++i)
+      directive_handler_->RemoveDirectives(unsubscribes.Get(i));
+  }
+}
+
+void RpcHandler::AddPlayingTokens(ReportRequest* request) {
+  if (!directive_handler_)
+    return;
+
+  const std::string& audible_token = directive_handler_->CurrentAudibleToken();
+  const std::string& inaudible_token =
+      directive_handler_->CurrentInaudibleToken();
+
+  if (!audible_token.empty())
+    AddTokenToRequest(request, AudioToken(audible_token, true));
+  if (!inaudible_token.empty())
+    AddTokenToRequest(request, AudioToken(inaudible_token, false));
+}
+
 void RpcHandler::DispatchMessages(
     const RepeatedPtrField<SubscribedMessage>& messages) {
   if (messages.size() == 0)
     return;
 
   // Index the messages by subscription id.
   std::map<std::string, std::vector<Message> > messages_by_subscription;
   DVLOG(3) << "Dispatching " << messages.size() << " messages";
   for (int m = 0; m < messages.size(); ++m) {
     const RepeatedPtrField<std::string>& subscription_ids =
@@ skipping 72 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