Renaming RMQStore to GCMStore and breaking out its interface

google_apis/gcm/engine/mcs_client_unittest.cc

 // Copyright 2013 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 "google_apis/gcm/engine/mcs_client.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "components/webdata/encryptor/encryptor.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
+#include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
 const uint64 kAndroidId = 54321;
 const uint64 kSecurityToken = 12345;
 
 // Number of messages to send when testing batching.
@@ skipping 24 matching lines @@
   data_message.set_ttl(ttl);
   data_message.set_sent(sent);
   return MCSMessage(kDataMessageStanzaTag, data_message);
 }
 
 // MCSClient with overriden exposed persistent id logic.
 class TestMCSClient : public MCSClient {
  public:
   TestMCSClient(base::Clock* clock,
                 ConnectionFactory* connection_factory,
-                RMQStore* rmq_store)
-    : MCSClient(clock, connection_factory, rmq_store),
+                GCMStore* gcm_store)
+    : MCSClient(clock, connection_factory, gcm_store),
       next_id_(0) {
   }
 
   virtual std::string GetNextPersistentId() OVERRIDE {
     return base::UintToString(++next_id_);
   }
 
  private:
   uint32 next_id_;
 };
@@ skipping 28 matching lines @@
                               uint64 restored_android_id,
                               uint64 restored_security_token);
   void MessageReceivedCallback(const MCSMessage& message);
   void MessageSentCallback(const std::string& message_id);
 
   base::SimpleTestClock clock_;
 
   base::ScopedTempDir temp_directory_;
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
-  scoped_ptr<RMQStore> rmq_store_;
+  scoped_ptr<GCMStore> gcm_store_;
 
   FakeConnectionFactory connection_factory_;
   scoped_ptr<TestMCSClient> mcs_client_;
   bool init_success_;
   uint64 restored_android_id_;
   uint64 restored_security_token_;
   scoped_ptr<MCSMessage> received_message_;
   std::string sent_message_id_;
 };
 
 MCSClientTest::MCSClientTest()
     : run_loop_(new base::RunLoop()),
       init_success_(false),
       restored_android_id_(0),
       restored_security_token_(0) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
   run_loop_.reset(new base::RunLoop());
 
   // On OSX, prevent the Keychain permissions popup during unit tests.
 #if defined(OS_MACOSX)
     Encryptor::UseMockKeychain(true);
 #endif
 }
 
 MCSClientTest::~MCSClientTest() {}
 
 void MCSClientTest::BuildMCSClient() {
-  rmq_store_.reset(new RMQStore(temp_directory_.path(),
-                                message_loop_.message_loop_proxy()));
+  gcm_store_.reset(new GCMStoreImpl(temp_directory_.path(),
+                                    message_loop_.message_loop_proxy()));
   mcs_client_.reset(new TestMCSClient(&clock_,
                                       &connection_factory_,
-                                      rmq_store_.get()));
+                                      gcm_store_.get()));
 }
 
 void MCSClientTest::InitializeClient() {
-  rmq_store_->Load(
-      base::Bind(&MCSClient::Initialize,
-                 base::Unretained(mcs_client_.get()),
-                 base::Bind(&MCSClientTest::InitializationCallback,
-                            base::Unretained(this)),
-                 base::Bind(&MCSClientTest::MessageReceivedCallback,
-                            base::Unretained(this)),
-                 base::Bind(&MCSClientTest::MessageSentCallback,
-                            base::Unretained(this))));
+  gcm_store_->Load(base::Bind(
+      &MCSClient::Initialize,
+      base::Unretained(mcs_client_.get()),
+      base::Bind(&MCSClientTest::InitializationCallback,
+                 base::Unretained(this)),
+      base::Bind(&MCSClientTest::MessageReceivedCallback,
+                 base::Unretained(this)),
+      base::Bind(&MCSClientTest::MessageSentCallback, base::Unretained(this))));
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
 
 void MCSClientTest::LoginClient(
     const std::vector<std::string>& acknowledged_ids) {
   scoped_ptr<mcs_proto::LoginRequest> login_request =
       BuildLoginRequest(kAndroidId, kSecurityToken);
   for (size_t i = 0; i < acknowledged_ids.size(); ++i)
     login_request->add_received_persistent_id(acknowledged_ids[i]);
@@ skipping 51 matching lines @@
   EXPECT_TRUE(init_success());
 }
 
 // Initialize a new client, shut it down, then restart the client. Should
 // reload the existing device credentials.
 TEST_F(MCSClientTest, InitializeExisting) {
   BuildMCSClient();
   InitializeClient();
   LoginClient(std::vector<std::string>());
 
-  // Rebuild the client, to reload from the RMQ.
+  // Rebuild the client, to reload from the GCM store.
   BuildMCSClient();
   InitializeClient();
   EXPECT_EQ(kAndroidId, restored_android_id());
   EXPECT_EQ(kSecurityToken, restored_security_token());
   EXPECT_TRUE(init_success());
 }
 
 // Log in successfully to the MCS endpoint.
 TEST_F(MCSClientTest, LoginSuccess) {
   BuildMCSClient();
@@ skipping 371 matching lines @@
   InitializeClient();
   LoginClient(std::vector<std::string>());
   PumpLoop();
   EXPECT_FALSE(sent_message_id().empty());
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 } // namespace
 
 }  // namespace gcm