Moved //components/proximity_auth/cryptauth to //components/cryptauth.

components/cryptauth/cryptauth_gcm_manager_impl_unittest.cc

 // Copyright 2015 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/proximity_auth/cryptauth/cryptauth_gcm_manager_impl.h"
+#include "components/cryptauth/cryptauth_gcm_manager_impl.h"
 
 #include "base/macros.h"
+#include "components/cryptauth/pref_names.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
 #include "components/gcm_driver/gcm_client.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/proximity_auth/cryptauth/pref_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::SaveArg;
 
-namespace proximity_auth {
+namespace cryptauth {
 
 namespace {
 
 const char kCryptAuthGCMAppId[] = "com.google.chrome.cryptauth";
 const char kCryptAuthGCMSenderId[] = "381449029288";
 const char kExistingGCMRegistrationId[] = "cirrus";
 const char kNewGCMRegistrationId[] = "stratus";
 const char kCryptAuthMessageCollapseKey[] =
     "collapse_cryptauth_sync_DEVICES_SYNC";
 
@@ skipping 11 matching lines @@
                     const std::vector<std::string>& sender_ids));
 
   using gcm::GCMDriver::RegisterFinished;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockGCMDriver);
 };
 
 }  // namespace
 
-class ProximityAuthCryptAuthGCMManagerImplTest
+class CryptAuthGCMManagerImplTest
     : public testing::Test,
       public CryptAuthGCMManager::Observer {
  protected:
-  ProximityAuthCryptAuthGCMManagerImplTest()
+  CryptAuthGCMManagerImplTest()
       : gcm_manager_(&gcm_driver_, &pref_service_) {}
 
   // testing::Test:
   void SetUp() override {
     CryptAuthGCMManager::RegisterPrefs(pref_service_.registry());
     gcm_manager_.AddObserver(this);
     EXPECT_CALL(gcm_driver_, AddAppHandler(kCryptAuthGCMAppId, &gcm_manager_));
     gcm_manager_.StartListening();
   }
 
@@ skipping 26 matching lines @@
   MOCK_METHOD1(OnGCMRegistrationResultProxy, void(bool));
   MOCK_METHOD0(OnReenrollMessageProxy, void());
   MOCK_METHOD0(OnResyncMessageProxy, void());
 
   testing::StrictMock<MockGCMDriver> gcm_driver_;
 
   TestingPrefServiceSimple pref_service_;
 
   CryptAuthGCMManagerImpl gcm_manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(ProximityAuthCryptAuthGCMManagerImplTest);
+  DISALLOW_COPY_AND_ASSIGN(CryptAuthGCMManagerImplTest);
 };
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest, RegisterPrefs) {
+TEST_F(CryptAuthGCMManagerImplTest, RegisterPrefs) {
   TestingPrefServiceSimple pref_service;
   CryptAuthGCMManager::RegisterPrefs(pref_service.registry());
   EXPECT_TRUE(pref_service.FindPreference(prefs::kCryptAuthGCMRegistrationId));
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest, RegistrationSucceeds) {
+TEST_F(CryptAuthGCMManagerImplTest, RegistrationSucceeds) {
   EXPECT_EQ(std::string(), gcm_manager_.GetRegistrationId());
   RegisterWithGCM(gcm::GCMClient::SUCCESS);
   EXPECT_EQ(kNewGCMRegistrationId, gcm_manager_.GetRegistrationId());
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest,
+TEST_F(CryptAuthGCMManagerImplTest,
        RegistrationSucceedsWithExistingRegistration) {
   pref_service_.SetString(prefs::kCryptAuthGCMRegistrationId,
                           kExistingGCMRegistrationId);
   EXPECT_EQ(kExistingGCMRegistrationId, gcm_manager_.GetRegistrationId());
   RegisterWithGCM(gcm::GCMClient::SUCCESS);
   EXPECT_EQ(kNewGCMRegistrationId, gcm_manager_.GetRegistrationId());
   EXPECT_EQ(kNewGCMRegistrationId,
             pref_service_.GetString(prefs::kCryptAuthGCMRegistrationId));
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest, RegisterWithGCMFails) {
+TEST_F(CryptAuthGCMManagerImplTest, RegisterWithGCMFails) {
   EXPECT_EQ(std::string(), gcm_manager_.GetRegistrationId());
   RegisterWithGCM(gcm::GCMClient::SERVER_ERROR);
   EXPECT_EQ(std::string(), gcm_manager_.GetRegistrationId());
   EXPECT_EQ(std::string(),
             pref_service_.GetString(prefs::kCryptAuthGCMRegistrationId));
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest,
+TEST_F(CryptAuthGCMManagerImplTest,
        RegisterWithGCMFailsWithExistingRegistration) {
   pref_service_.SetString(prefs::kCryptAuthGCMRegistrationId,
                           kExistingGCMRegistrationId);
   EXPECT_EQ(kExistingGCMRegistrationId, gcm_manager_.GetRegistrationId());
   RegisterWithGCM(gcm::GCMClient::SERVER_ERROR);
   EXPECT_EQ(kExistingGCMRegistrationId, gcm_manager_.GetRegistrationId());
   EXPECT_EQ(kExistingGCMRegistrationId,
             pref_service_.GetString(prefs::kCryptAuthGCMRegistrationId));
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest,
+TEST_F(CryptAuthGCMManagerImplTest,
        RegistrationFailsThenSucceeds) {
   EXPECT_EQ(std::string(), gcm_manager_.GetRegistrationId());
   RegisterWithGCM(gcm::GCMClient::NETWORK_ERROR);
   EXPECT_EQ(std::string(), gcm_manager_.GetRegistrationId());
   RegisterWithGCM(gcm::GCMClient::SUCCESS);
   EXPECT_EQ(kNewGCMRegistrationId, gcm_manager_.GetRegistrationId());
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest, ConcurrentRegistrations) {
+TEST_F(CryptAuthGCMManagerImplTest, ConcurrentRegistrations) {
   // If multiple RegisterWithGCM() calls are made concurrently, only one
   // registration attempt should actually be made.
   EXPECT_CALL(gcm_driver_, RegisterImpl(kCryptAuthGCMAppId, _));
   gcm_manager_.RegisterWithGCM();
   gcm_manager_.RegisterWithGCM();
   gcm_manager_.RegisterWithGCM();
 
   EXPECT_CALL(*this, OnGCMRegistrationResultProxy(true));
   gcm_driver_.RegisterFinished(kCryptAuthGCMAppId, kNewGCMRegistrationId,
                                gcm::GCMClient::SUCCESS);
   EXPECT_EQ(kNewGCMRegistrationId, gcm_manager_.GetRegistrationId());
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest, ReenrollmentMessagesReceived) {
+TEST_F(CryptAuthGCMManagerImplTest, ReenrollmentMessagesReceived) {
   EXPECT_CALL(*this, OnReenrollMessageProxy()).Times(2);
 
   gcm::IncomingMessage message;
   message.data["registrationTickleType"] = "1";  // FORCE_ENROLLMENT
   message.collapse_key = kCryptAuthMessageCollapseKey;
   message.sender_id = kCryptAuthGCMSenderId;
 
   gcm::GCMAppHandler* gcm_app_handler =
       static_cast<gcm::GCMAppHandler*>(&gcm_manager_);
   gcm_app_handler->OnMessage(kCryptAuthGCMAppId, message);
   message.data["registrationTickleType"] = "2";  // UPDATE_ENROLLMENT
   gcm_app_handler->OnMessage(kCryptAuthGCMAppId, message);
 }
 
-TEST_F(ProximityAuthCryptAuthGCMManagerImplTest, ResyncMessagesReceived) {
+TEST_F(CryptAuthGCMManagerImplTest, ResyncMessagesReceived) {
   EXPECT_CALL(*this, OnResyncMessageProxy()).Times(2);
 
   gcm::IncomingMessage message;
   message.data["registrationTickleType"] = "3";  // DEVICES_SYNC
   message.collapse_key = kCryptAuthMessageCollapseKey;
   message.sender_id = kCryptAuthGCMSenderId;
 
   gcm::GCMAppHandler* gcm_app_handler =
       static_cast<gcm::GCMAppHandler*>(&gcm_manager_);
   gcm_app_handler->OnMessage(kCryptAuthGCMAppId, message);
   gcm_app_handler->OnMessage(kCryptAuthGCMAppId, message);
 }
 
-}  // namespace proximity_auth
+}  // namespace cryptauth