Revert of Adding CopresenceState

components/copresence/copresence_state_unittest.cc

Index: components/copresence/copresence_state_unittest.cc
diff --git a/components/copresence/copresence_state_unittest.cc b/components/copresence/copresence_state_unittest.cc
deleted file mode 100644
index 4817e7e426b07d0b70aece3d260a016b700d5c99..0000000000000000000000000000000000000000
--- a/components/copresence/copresence_state_unittest.cc
+++ /dev/null
@@ -1,149 +0,0 @@
-// 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 <string>
-#include <vector>
-
-#include "base/time/time.h"
-#include "components/copresence/copresence_state_impl.h"
-#include "components/copresence/proto/data.pb.h"
-#include "components/copresence/public/copresence_observer.h"
-#include "components/copresence/tokens.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-using testing::ElementsAre;
-using testing::Key;
-using testing::SizeIs;
-using testing::UnorderedElementsAre;
-
-// TODO(ckehoe): Test start and end time tracking.
-
-namespace google {
-namespace protobuf {
-
-bool operator==(const MessageLite& A, const MessageLite& B) {
-  std::string serializedA;
-  CHECK(A.SerializeToString(&serializedA));
-
-  std::string serializedB;
-  CHECK(B.SerializeToString(&serializedB));
-
-  return serializedA == serializedB;
-}
-
-}  // namespace protobuf
-}  // namespace google
-
-namespace copresence {
-
-namespace {
-
-const base::Time kStartTime = base::Time::FromDoubleT(10);
-const base::Time kStopTime = base::Time::FromDoubleT(20);
-
-Directive CreateDirective(const std::string& token, bool transmit) {
-  Directive directive;
-  TokenInstruction* instruction = directive.mutable_token_instruction();
-  instruction->set_token_id(token);
-  instruction->set_medium(AUDIO_ULTRASOUND_PASSBAND);
-  if (transmit)
-    instruction->set_token_instruction_type(TRANSMIT);
-  return directive;
-}
-
-template<typename TokenType>
-TokenType CreateToken(const std::string& id) {
-  TokenType token;
-  token.id = id;
-  token.medium = AUDIO_ULTRASOUND_PASSBAND;
-  token.start_time = kStartTime;
-  return token;
-}
-
-}  // namespace
-
-class CopresenceStateTest : public CopresenceObserver,
-                                  public testing::Test {
- public:
-  CopresenceStateTest() : directive_notifications_(0) {
-    state_.AddObserver(this);
-  }
-
- protected:
-  CopresenceStateImpl state_;
-
-  int directive_notifications_;
-  std::vector<std::string> transmitted_updates_;
-  std::vector<std::string> received_updates_;
-
- private:
-  // CopresenceObserver implementation.
-  void DirectivesUpdated() override {
-    directive_notifications_++;
-  }
-  void TokenTransmitted(const TransmittedToken& token) override {
-    transmitted_updates_.push_back(token.id);
-  }
-  void TokenReceived(const ReceivedToken& token) override {
-    received_updates_.push_back(token.id);
-  }
-};
-
-TEST_F(CopresenceStateTest, Directives) {
-  std::vector<Directive> directives;
-  directives.push_back(CreateDirective("transmit 1", true));
-  directives.push_back(CreateDirective("transmit 2", true));
-  directives.push_back(CreateDirective("receive", false));
-  state_.UpdateDirectives(directives);
-
-  EXPECT_EQ(1, directive_notifications_);
-  EXPECT_EQ(directives, state_.active_directives());
-  EXPECT_THAT(transmitted_updates_, ElementsAre("transmit 1", "transmit 2"));
-  EXPECT_THAT(state_.transmitted_tokens(),
-              UnorderedElementsAre(Key("transmit 1"), Key("transmit 2")));
-
-  directives.clear();
-  directives.push_back(CreateDirective("transmit 1", true));
-  state_.UpdateDirectives(directives);
-  EXPECT_EQ(2, directive_notifications_);
-  EXPECT_EQ(directives, state_.active_directives());
-  EXPECT_THAT(state_.transmitted_tokens(), SizeIs(2));
-}
-
-TEST_F(CopresenceStateTest, TransmittedTokens) {
-  state_.UpdateTransmittedToken(CreateToken<TransmittedToken>("A"));
-  state_.UpdateTransmittedToken(CreateToken<TransmittedToken>("B"));
-
-  EXPECT_THAT(transmitted_updates_, ElementsAre("A", "B"));
-  EXPECT_THAT(state_.transmitted_tokens(),
-              UnorderedElementsAre(Key("A"), Key("B")));
-
-  TransmittedToken tokenA = CreateToken<TransmittedToken>("A");
-  tokenA.stop_time = kStopTime;
-  state_.UpdateTransmittedToken(tokenA);
-
-  EXPECT_THAT(transmitted_updates_, ElementsAre("A", "B", "A"));
-  EXPECT_EQ(kStopTime, state_.transmitted_tokens().find("A")->second.stop_time);
-
-  state_.UpdateReceivedToken(CreateToken<ReceivedToken>("B"));
-  EXPECT_THAT(transmitted_updates_, ElementsAre("A", "B", "A", "B"));
-  EXPECT_TRUE(state_.transmitted_tokens().find("B")
-                  ->second.broadcast_confirmed);
-}
-
-TEST_F(CopresenceStateTest, ReceivedTokens) {
-  state_.UpdateReceivedToken(CreateToken<ReceivedToken>("A"));
-  state_.UpdateReceivedToken(CreateToken<ReceivedToken>("B"));
-
-  EXPECT_THAT(received_updates_, ElementsAre("A", "B"));
-  EXPECT_THAT(state_.received_tokens(),
-              UnorderedElementsAre(Key("A"), Key("B")));
-
-  state_.UpdateTokenStatus("A", copresence::VALID);
-  EXPECT_THAT(received_updates_, ElementsAre("A", "B", "A"));
-  EXPECT_EQ(ReceivedToken::VALID,
-            state_.received_tokens().find("A")->second.valid);
-}
-
-}  // namespace copresence