Moving the DirectiveHandler to be owned by CopresenceManager.

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"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 
 // TODO(ckehoe): time.h includes windows.h, which #defines DeviceCapabilities
 // to DeviceCapabilitiesW. This breaks the pb.h headers below. For now,
 // we fix this with an #undef.
 #include "base/time/time.h"
 #if defined(OS_WIN)
 #undef DeviceCapabilities
 #endif
 
 #include "components/copresence/copresence_switches.h"
 #include "components/copresence/handlers/directive_handler.h"
 #include "components/copresence/proto/codes.pb.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
 #include "components/copresence/public/copresence_constants.h"
 #include "components/copresence/public/copresence_delegate.h"
+#include "components/copresence/public/whispernet_client.h"
+#include "components/copresence/rpc/http_post.h"
 #include "net/http/http_status_code.h"
 
 // TODO(ckehoe): Return error messages for bad requests.
 
 namespace copresence {
 
 using google::protobuf::MessageLite;
 using google::protobuf::RepeatedPtrField;
 
 const char RpcHandler::kReportRequestRpcName[] = "report";
@@ skipping 103 matching lines @@
   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(CopresenceDelegate* delegate)
+RpcHandler::RpcHandler(CopresenceDelegate* delegate,
+                       DirectiveHandler* directive_handler)
     : delegate_(delegate),
+      directive_handler_(directive_handler),
       invalid_audio_token_cache_(
           base::TimeDelta::FromMilliseconds(kInvalidTokenExpiryTimeMs),
           kMaxInvalidTokens),
       server_post_callback_(base::Bind(&RpcHandler::SendHttpPost,
-                                       base::Unretained(this))) {}
+                                       base::Unretained(this))) {
+    DCHECK(delegate_);
+    DCHECK(directive_handler_);
+  }
 
 RpcHandler::~RpcHandler() {
   for (HttpPost* post : pending_posts_) {
     delete post;
   }
 
-  if (delegate_ && delegate_->GetWhispernetClient()) {
+  if (delegate_->GetWhispernetClient()) {
+    // TODO(ckehoe): Use CancelableCallbacks instead.
     delegate_->GetWhispernetClient()->RegisterTokensCallback(
         WhispernetClient::TokensCallback());
     delegate_->GetWhispernetClient()->RegisterSamplesCallback(
         WhispernetClient::SamplesCallback());
   }
 }
 
 void RpcHandler::RegisterForToken(const std::string& auth_token,
                                   const SuccessCallback& init_done_callback) {
   if (IsRegisteredForToken(auth_token)) {
@@ skipping 93 matching lines @@
     AddTokenToRequest(token, &request);
   }
 
   // Report under all active tokens.
   for (const auto& registration : device_id_by_auth_token_) {
     SendReportRequest(make_scoped_ptr(new ReportRequest(request)),
                       registration.first);
   }
 }
 
-void RpcHandler::ConnectToWhispernet() {
-  // Check if we are already connected.
-  if (directive_handler_)
-    return;
-
-  WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
-
-  // |directive_handler_| will be destructed with us, so unretained is safe.
-  directive_handler_.reset(new DirectiveHandler);
-  directive_handler_->Initialize(
-      base::Bind(&WhispernetClient::DecodeSamples,
-                 base::Unretained(whispernet_client)),
-      base::Bind(&RpcHandler::AudioDirectiveListToWhispernetConnector,
-                 base::Unretained(this)));
-
-  whispernet_client->RegisterTokensCallback(
-      base::Bind(&RpcHandler::ReportTokens,
-                 // On destruction, this callback will be disconnected.
-                 base::Unretained(this)));
-}
-
 // Private methods
 
 void RpcHandler::RegisterResponseHandler(
     const SuccessCallback& init_done_callback,
     const std::string& auth_token,
     HttpPost* completed_post,
     int http_status_code,
     const std::string& response_data) {
   if (completed_post) {
     int elements_erased = pending_posts_.erase(completed_post);
@@ skipping 65 matching lines @@
   for (const SubscriptionResult& result :
       response.manage_subscriptions_response().subscription_result()) {
     DVLOG(2) << "Created subscription with id " << result.subscription_id();
   }
 
   if (response.has_update_signals_response()) {
     const UpdateSignalsResponse& update_response =
         response.update_signals_response();
     DispatchMessages(update_response.message());
 
-    if (directive_handler_.get()) {
-      for (const Directive& directive : update_response.directive())
-        directive_handler_->AddDirective(directive);
-    } else {
-      DVLOG(1) << "No directive handler.";
-    }
+    for (const Directive& directive : update_response.directive())
+      directive_handler_->AddDirective(directive);
 
     for (const Token& token : update_response.token()) {
       switch (token.status()) {
         case VALID:
           // TODO(rkc/ckehoe): Store the token in a |valid_token_cache_| with a
           // short TTL (like 10s) and send it up with every report request.
           // Then we'll still get messages while we're waiting to hear it again.
           VLOG(1) << "Got valid token " << token.id();
           break;
         case INVALID:
@@ skipping 24 matching lines @@
   // Remove unsubscribes.
   if (request.has_manage_subscriptions_request()) {
     for (const std::string& unsubscribe :
         request.manage_subscriptions_request().id_to_unsubscribe()) {
       directive_handler_->RemoveDirectives(unsubscribe);
     }
   }
 }
 
 void RpcHandler::AddPlayingTokens(ReportRequest* request) {
-  if (!directive_handler_)
-    return;
-
   const std::string& audible_token =
       directive_handler_->GetCurrentAudioToken(AUDIBLE);
   const std::string& inaudible_token =
       directive_handler_->GetCurrentAudioToken(INAUDIBLE);
 
   if (!audible_token.empty())
     AddTokenToRequest(AudioToken(audible_token, true), request);
   if (!inaudible_token.empty())
     AddTokenToRequest(AudioToken(inaudible_token, false), request);
 }
@@ skipping 16 matching lines @@
   // Send the messages for each subscription.
   for (const auto& map_entry : messages_by_subscription) {
     // TODO(ckehoe): Once we have the app ID from the server, we need to pass
     // it in here and get rid of the app id registry from the main API class.
     const std::string& subscription = map_entry.first;
     const std::vector<Message>& messages = map_entry.second;
     delegate_->HandleMessages(std::string(), subscription, messages);
   }
 }
 
+// TODO(ckehoe): Pass in the version string and
+// group this with the local functions up top.
 RequestHeader* RpcHandler::CreateRequestHeader(
     const std::string& client_name,
     const std::string& device_id) const {
   RequestHeader* header = new RequestHeader;
 
   header->set_allocated_framework_version(CreateVersion(
       "Chrome", delegate_->GetPlatformVersionString()));
   if (!client_name.empty()) {
     header->set_allocated_client_version(
         CreateVersion(client_name, std::string()));
@@ skipping 46 matching lines @@
       rpc_name,
       api_key,
       auth_token,
       command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken),
       *request_proto);
 
   http_post->Start(base::Bind(callback, http_post));
   pending_posts_.insert(http_post);
 }
 
-void RpcHandler::AudioDirectiveListToWhispernetConnector(
-    const std::string& token,
-    AudioType type,
-    const WhispernetClient::SamplesCallback& samples_callback) {
-  DCHECK(type == AUDIBLE || type == INAUDIBLE);
-  WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
-  if (whispernet_client) {
-    whispernet_client->RegisterSamplesCallback(samples_callback);
-    whispernet_client->EncodeToken(token, type);
-  }
-}
-
 }  // namespace copresence