Add polling and audio check to copresence.

components/copresence/rpc/rpc_handler_unittest.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 <string>
 #include <vector>
 
@@ skipping 28 matching lines @@
                              SubscribedMessage* message_proto) {
   message_proto->mutable_published_message()->set_payload(message_string);
   for (const std::string& subscription_id : subscription_ids) {
     message_proto->add_subscription_id(subscription_id);
   }
 }
 
 // TODO(ckehoe): Make DirectiveHandler an interface.
 class FakeDirectiveHandler final : public DirectiveHandler {
  public:
-  FakeDirectiveHandler() {}
+  FakeDirectiveHandler() : DirectiveHandler(nullptr) {}
 
   const std::vector<std::string>& added_directives() const {
     return added_directives_;
   }
 
-  void Start(WhispernetClient* /* whispernet_client */) override {
+  void Start(WhispernetClient* /* whispernet_client */,
+             const TokensCallback& /* tokens_cb */) override {
     NOTREACHED();
   }
 
   void AddDirective(const Directive& directive) override {
     added_directives_.push_back(directive.subscription_id());
   }
 
   void RemoveDirectives(const std::string& op_id) override {
     NOTREACHED();
   }
 
   const std::string GetCurrentAudioToken(AudioType type) const override {
     return type == AUDIBLE ? "current audible" : "current inaudible";
   }
 
+  bool IsAudioTokenHeard(AudioType type) const override { return true; }
+
  private:
   std::vector<std::string> added_directives_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDirectiveHandler);
 };
 
 }  // namespace
 
 class RpcHandlerTest : public testing::Test, public CopresenceDelegate {
  public:
   RpcHandlerTest()
-    : whispernet_client_(new StubWhispernetClient),
-      rpc_handler_(this,
-                   &directive_handler_,
-                   base::Bind(&RpcHandlerTest::CaptureHttpPost,
-                              base::Unretained(this))),
-      status_(SUCCESS) {}
+      : whispernet_client_(new StubWhispernetClient),
+        rpc_handler_(this,
+                     &directive_handler_,
+                     base::Bind(&RpcHandlerTest::CaptureHttpPost,
+                                base::Unretained(this))),
+        status_(SUCCESS) {}
 
   // CopresenceDelegate implementation
 
   void HandleMessages(const std::string& /* app_id */,
                       const std::string& subscription_id,
                       const std::vector<Message>& messages) override {
     // app_id is unused for now, pending a server fix.
     for (const Message& message : messages) {
       messages_by_subscription_[subscription_id].push_back(message.payload());
     }
   }
 
+  void HandleStatusUpdate(CopresenceStatus /* status */) override {}
+
   net::URLRequestContextGetter* GetRequestContext() const override {
     return nullptr;
   }
 
   const std::string GetPlatformVersionString() const override {
     return kChromeVersion;
   }
 
   const std::string GetAPIKey(const std::string& app_id) const override {
     return app_id + " API Key";
@@ skipping 173 matching lines @@
   EXPECT_THAT(messages_by_subscription_["Subscription 1"],
               ElementsAre("Message A", "Message C"));
   EXPECT_THAT(messages_by_subscription_["Subscription 2"],
               ElementsAre("Message B", "Message C"));
 
   EXPECT_THAT(directive_handler_.added_directives(),
               ElementsAre("Subscription 1", "Subscription 2"));
 }
 
 }  // namespace copresence