Revert "Adding GCM support to the copresence component. The Copresence server can push directives (…

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "components/copresence/handlers/directive_handler.h"
 #include "components/copresence/mediums/audio/audio_manager.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
-#include "components/copresence/test/fake_directive_handler.h"
 #include "components/copresence/test/stub_whispernet_client.h"
 #include "net/http/http_status_code.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using google::protobuf::MessageLite;
 using google::protobuf::RepeatedPtrField;
 
 using testing::ElementsAre;
 using testing::Property;
 using testing::SizeIs;
 
 namespace copresence {
 
 namespace {
 
 const char kChromeVersion[] = "Chrome Version String";
 
 void CreateSubscribedMessage(const std::vector<std::string>& subscription_ids,
                              const std::string& message_string,
                              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() : DirectiveHandler(nullptr) {}
+
+  const std::vector<std::string>& added_directives() const {
+    return added_directives_;
+  }
+
+  const std::vector<std::string>& removed_directives() const {
+    return removed_directives_;
+  }
+
+  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 {
+    removed_directives_.push_back(op_id);
+  }
+
+  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_;
+  std::vector<std::string> removed_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_,
-                     nullptr,
                      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.
@@ skipping 13 matching lines @@
   }
 
   const std::string GetAPIKey(const std::string& app_id) const override {
     return app_id + " API Key";
   }
 
   WhispernetClient* GetWhispernetClient() override {
     return whispernet_client_.get();
   }
 
-  // TODO(ckehoe): Add GCM tests.
-  gcm::GCMDriver* GetGCMDriver() override {
-    return nullptr;
-  }
-
  protected:
 
   // Send test input to RpcHandler
 
   void RegisterForToken(const std::string& auth_token) {
     rpc_handler_.RegisterForToken(auth_token);
   }
 
   void SendRegisterResponse(const std::string& auth_token,
                             const std::string& device_id) {
     RegisterDeviceResponse response;
     response.set_registered_device_id(device_id);
     response.mutable_header()->mutable_status()->set_code(OK);
 
     std::string serialized_response;
     response.SerializeToString(&serialized_response);
     rpc_handler_.RegisterResponseHandler(
-        auth_token, false, nullptr, net::HTTP_OK, serialized_response);
+        auth_token, nullptr, net::HTTP_OK, serialized_response);
   }
 
   void SendReport(scoped_ptr<ReportRequest> request,
                   const std::string& app_id,
                   const std::string& auth_token) {
     rpc_handler_.SendReportRequest(
       request.Pass(), app_id, auth_token, StatusCallback());
   }
 
   void SendReportResponse(int status_code,
@@ skipping 227 matching lines @@
   EXPECT_TRUE(TokenIsInvalid("bad token"));
   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