Renaming RMQStore to GCMStore and breaking out its interface

google_apis/gcm/engine/gcm_store_impl.cc

Index: google_apis/gcm/engine/gcm_store_impl.cc
diff --git a/google_apis/gcm/engine/rmq_store.cc b/google_apis/gcm/engine/gcm_store_impl.cc
similarity index 64%
rename from google_apis/gcm/engine/rmq_store.cc
rename to google_apis/gcm/engine/gcm_store_impl.cc
index 49c6809785974903cfce6a4ede966547a8f02326..8f333a855868e5353b095b8bf323d86e18a77388 100644
--- a/google_apis/gcm/engine/rmq_store.cc
+++ b/google_apis/gcm/engine/gcm_store_impl.cc
@@ -2,7 +2,7 @@
 // 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/rmq_store.h"
+#include "google_apis/gcm/engine/gcm_store_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ -80,12 +80,13 @@ leveldb::Slice MakeSlice(const base::StringPiece& s) {
 
 }  // namespace
 
-class RMQStore::Backend : public base::RefCountedThreadSafe<RMQStore::Backend> {
+class GCMStoreImpl::Backend
+    : public base::RefCountedThreadSafe<GCMStoreImpl::Backend> {
  public:
   Backend(const base::FilePath& path,
           scoped_refptr<base::SequencedTaskRunner> foreground_runner);
 
-  // Blocking implementations of RMQStore methods.
+  // Blocking implementations of GCMStoreImpl methods.
   void Load(const LoadCallback& callback);
   void Destroy(const UpdateCallback& callback);
   void SetDeviceCredentials(uint64 device_android_id,
@@ -125,30 +126,25 @@ class RMQStore::Backend : public base::RefCountedThreadSafe<RMQStore::Backend> {
   scoped_ptr<leveldb::DB> db_;
 };
 
-RMQStore::Backend::Backend(
+GCMStoreImpl::Backend::Backend(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> foreground_task_runner)
-    : path_(path),
-      foreground_task_runner_(foreground_task_runner) {
-}
+    : path_(path), foreground_task_runner_(foreground_task_runner) {}
 
-RMQStore::Backend::~Backend() {
-}
+GCMStoreImpl::Backend::~Backend() {}
 
-void RMQStore::Backend::Load(const LoadCallback& callback) {
+void GCMStoreImpl::Backend::Load(const LoadCallback& callback) {
   LoadResult result;
 
   leveldb::Options options;
   options.create_if_missing = true;
   leveldb::DB* db;
-  leveldb::Status status = leveldb::DB::Open(options,
-                                             path_.AsUTF8Unsafe(),
-                                             &db);
+  leveldb::Status status =
+      leveldb::DB::Open(options, path_.AsUTF8Unsafe(), &db);
   if (!status.ok()) {
-    LOG(ERROR) << "Failed to open database " << path_.value()
-               << ": " << status.ToString();
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, result));
+    LOG(ERROR) << "Failed to open database " << path_.value() << ": "
+               << status.ToString();
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
     return;
   }
   db_.reset(db);
@@ -165,39 +161,35 @@ void RMQStore::Backend::Load(const LoadCallback& callback) {
     STLDeleteContainerPairSecondPointers(result.outgoing_messages.begin(),
                                          result.outgoing_messages.end());
     result.outgoing_messages.clear();
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, result));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
     return;
   }
 
   DVLOG(1) << "Succeeded in loading " << result.incoming_messages.size()
-          << " unacknowledged incoming messages and "
-          << result.outgoing_messages.size()
-          << " unacknowledged outgoing messages.";
+           << " unacknowledged incoming messages and "
+           << result.outgoing_messages.size()
+           << " unacknowledged outgoing messages.";
   result.success = true;
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, result));
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
   return;
 }
 
-void RMQStore::Backend::Destroy(const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::Destroy(const UpdateCallback& callback) {
   DVLOG(1) << "Destroying RMQ store.";
   const leveldb::Status s =
-      leveldb::DestroyDB(path_.AsUTF8Unsafe(),
-                         leveldb::Options());
+      leveldb::DestroyDB(path_.AsUTF8Unsafe(), leveldb::Options());
   if (s.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, true));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "Destroy failed.";
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, false));
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::SetDeviceCredentials(uint64 device_android_id,
-                                             uint64 device_security_token,
-                                             const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::SetDeviceCredentials(
+    uint64 device_android_id,
+    uint64 device_security_token,
+    const UpdateCallback& callback) {
   DVLOG(1) << "Saving device credentials with AID " << device_android_id;
   leveldb::WriteOptions write_options;
   write_options.sync = true;
@@ -210,41 +202,35 @@ void RMQStore::Backend::SetDeviceCredentials(uint64 device_android_id,
                MakeSlice(kDeviceAIDKey),
                MakeSlice(base::Uint64ToString(device_android_id)));
   if (s.ok()) {
-    s = db_->Put(write_options,
-                 MakeSlice(kDeviceTokenKey),
-                 MakeSlice(encrypted_token));
+    s = db_->Put(
+        write_options, MakeSlice(kDeviceTokenKey), MakeSlice(encrypted_token));
   }
   if (s.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, true));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB put failed: " << s.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, false));
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::AddIncomingMessage(const std::string& persistent_id,
-                                           const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::AddIncomingMessage(const std::string& persistent_id,
+                                               const UpdateCallback& callback) {
   DVLOG(1) << "Saving incoming message with id " << persistent_id;
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
-  const leveldb::Status s =
-      db_->Put(write_options,
-               MakeSlice(MakeIncomingKey(persistent_id)),
-               MakeSlice(persistent_id));
+  const leveldb::Status s = db_->Put(write_options,
+                                     MakeSlice(MakeIncomingKey(persistent_id)),
+                                     MakeSlice(persistent_id));
   if (s.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, true));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB put failed: " << s.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, false));
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::RemoveIncomingMessages(
+void GCMStoreImpl::Backend::RemoveIncomingMessages(
     const PersistentIdList& persistent_ids,
     const UpdateCallback& callback) {
   leveldb::WriteOptions write_options;
@@ -252,49 +238,42 @@ void RMQStore::Backend::RemoveIncomingMessages(
 
   leveldb::Status s;
   for (PersistentIdList::const_iterator iter = persistent_ids.begin();
-       iter != persistent_ids.end(); ++iter){
+       iter != persistent_ids.end();
+       ++iter) {
     DVLOG(1) << "Removing incoming message with id " << *iter;
-    s = db_->Delete(write_options,
-                    MakeSlice(MakeIncomingKey(*iter)));
+    s = db_->Delete(write_options, MakeSlice(MakeIncomingKey(*iter)));
     if (!s.ok())
       break;
   }
   if (s.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, true));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB remove failed: " << s.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, false));
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::AddOutgoingMessage(
-   const std::string& persistent_id,
-   const MCSMessage& message,
-   const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::AddOutgoingMessage(const std::string& persistent_id,
+                                               const MCSMessage& message,
+                                               const UpdateCallback& callback) {
   DVLOG(1) << "Saving outgoing message with id " << persistent_id;
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
-  std::string data = static_cast<char>(message.tag()) +
-      message.SerializeAsString();
-  const leveldb::Status s =
-      db_->Put(write_options,
-               MakeSlice(MakeOutgoingKey(persistent_id)),
-               MakeSlice(data));
+  std::string data =
+      static_cast<char>(message.tag()) + message.SerializeAsString();
+  const leveldb::Status s = db_->Put(write_options,
+                                     MakeSlice(MakeOutgoingKey(persistent_id)),
+                                     MakeSlice(data));
   if (s.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, true));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB put failed: " << s.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, false));
-
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::RemoveOutgoingMessages(
+void GCMStoreImpl::Backend::RemoveOutgoingMessages(
     const PersistentIdList& persistent_ids,
     const UpdateCallback& callback) {
   leveldb::WriteOptions write_options;
@@ -302,26 +281,25 @@ void RMQStore::Backend::RemoveOutgoingMessages(
 
   leveldb::Status s;
   for (PersistentIdList::const_iterator iter = persistent_ids.begin();
-       iter != persistent_ids.end(); ++iter){
+       iter != persistent_ids.end();
+       ++iter) {
     DVLOG(1) << "Removing outgoing message with id " << *iter;
-    s = db_->Delete(write_options,
-                    MakeSlice(MakeOutgoingKey(*iter)));
+    s = db_->Delete(write_options, MakeSlice(MakeOutgoingKey(*iter)));
     if (!s.ok())
       break;
   }
   if (s.ok()) {
-    foreground_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(callback, true));
+    foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB remove failed: " << s.ToString();
-  foreground_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(callback, false));
+  foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::AddUserSerialNumber(const std::string& username,
-                                            int64 serial_number,
-                                            const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::AddUserSerialNumber(
+    const std::string& username,
+    int64 serial_number,
+    const UpdateCallback& callback) {
   DVLOG(1) << "Saving username to serial number mapping for user: " << username;
   leveldb::WriteOptions write_options;
   write_options.sync = true;
@@ -338,8 +316,9 @@ void RMQStore::Backend::AddUserSerialNumber(const std::string& username,
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::RemoveUserSerialNumber(const std::string& username,
-                                               const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::RemoveUserSerialNumber(
+    const std::string& username,
+    const UpdateCallback& callback) {
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
@@ -352,8 +331,9 @@ void RMQStore::Backend::RemoveUserSerialNumber(const std::string& username,
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-void RMQStore::Backend::SetNextSerialNumber(int64 next_serial_number,
-                                            const UpdateCallback& callback) {
+void GCMStoreImpl::Backend::SetNextSerialNumber(
+    int64 next_serial_number,
+    const UpdateCallback& callback) {
   DVLOG(1) << "Updating the value of next user serial number to: "
            << next_serial_number;
   leveldb::WriteOptions write_options;
@@ -371,24 +351,20 @@ void RMQStore::Backend::SetNextSerialNumber(int64 next_serial_number,
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
-bool RMQStore::Backend::LoadDeviceCredentials(uint64* android_id,
-                                              uint64* security_token) {
+bool GCMStoreImpl::Backend::LoadDeviceCredentials(uint64* android_id,
+                                                  uint64* security_token) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   std::string result;
-  leveldb::Status s = db_->Get(read_options,
-                               MakeSlice(kDeviceAIDKey),
-                               &result);
+  leveldb::Status s = db_->Get(read_options, MakeSlice(kDeviceAIDKey), &result);
   if (s.ok()) {
     if (!base::StringToUint64(result, android_id)) {
       LOG(ERROR) << "Failed to restore device id.";
       return false;
     }
     result.clear();
-    s = db_->Get(read_options,
-                 MakeSlice(kDeviceTokenKey),
-                 &result);
+    s = db_->Get(read_options, MakeSlice(kDeviceTokenKey), &result);
   }
   if (s.ok()) {
     std::string decrypted_token;
@@ -409,7 +385,7 @@ bool RMQStore::Backend::LoadDeviceCredentials(uint64* android_id,
   return false;
 }
 
-bool RMQStore::Backend::LoadIncomingMessages(
+bool GCMStoreImpl::Backend::LoadIncomingMessages(
     std::vector<std::string>* incoming_messages) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
@@ -431,9 +407,8 @@ bool RMQStore::Backend::LoadIncomingMessages(
   return true;
 }
 
-bool RMQStore::Backend::LoadOutgoingMessages(
-    std::map<std::string, google::protobuf::MessageLite*>*
-        outgoing_messages) {
+bool GCMStoreImpl::Backend::LoadOutgoingMessages(
+    std::map<std::string, google::protobuf::MessageLite*>* outgoing_messages) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
@@ -452,8 +427,8 @@ bool RMQStore::Backend::LoadOutgoingMessages(
         BuildProtobufFromTag(tag));
     if (!message.get() ||
         !message->ParseFromString(iter->value().ToString().substr(1))) {
-      LOG(ERROR) << "Failed to parse outgoing message with id "
-                 << id << " and tag " << tag;
+      LOG(ERROR) << "Failed to parse outgoing message with id " << id
+                 << " and tag " << tag;
       return false;
     }
     DVLOG(1) << "Found outgoing message with id " << id << " of type "
@@ -464,14 +439,13 @@ bool RMQStore::Backend::LoadOutgoingMessages(
   return true;
 }
 
-bool RMQStore::Backend::LoadNextSerialNumber(int64* next_serial_number) {
+bool GCMStoreImpl::Backend::LoadNextSerialNumber(int64* next_serial_number) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   std::string result;
-  leveldb::Status status = db_->Get(read_options,
-                                    MakeSlice(kNextSerialNumberKey),
-                                    &result);
+  leveldb::Status status =
+      db_->Get(read_options, MakeSlice(kNextSerialNumberKey), &result);
   if (status.ok()) {
     if (!base::StringToInt64(result, next_serial_number)) {
       LOG(ERROR) << "Failed to restore the next serial number.";
@@ -489,7 +463,7 @@ bool RMQStore::Backend::LoadNextSerialNumber(int64* next_serial_number) {
   return false;
 }
 
-bool RMQStore::Backend::LoadUserSerialNumberMap(
+bool GCMStoreImpl::Backend::LoadUserSerialNumberMap(
     std::map<std::string, int64>* user_serial_number_map) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
@@ -516,140 +490,129 @@ bool RMQStore::Backend::LoadUserSerialNumberMap(
   return true;
 }
 
-RMQStore::LoadResult::LoadResult()
-    : success(false),
-      device_android_id(0),
-      device_security_token(0),
-      next_serial_number(1LL) {
-}
-RMQStore::LoadResult::~LoadResult() {}
-
-RMQStore::RMQStore(
+GCMStoreImpl::GCMStoreImpl(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : backend_(new Backend(path, base::MessageLoopProxy::current())),
-      blocking_task_runner_(blocking_task_runner) {
-}
+    : GCMStore(),

[jianli, 2014/01/02 19:02:53]

nit: Calling default constructor is not needed

[fgorski, 2014/01/02 19:46:33]

Done.

+      backend_(new Backend(path, base::MessageLoopProxy::current())),
+      blocking_task_runner_(blocking_task_runner) {}
 
-RMQStore::~RMQStore() {
-}
+GCMStoreImpl::~GCMStoreImpl() {}
 
-void RMQStore::Load(const LoadCallback& callback) {
-  blocking_task_runner_->PostTask(FROM_HERE,
-                                  base::Bind(&RMQStore::Backend::Load,
-                                             backend_,
-                                             callback));
+void GCMStoreImpl::Load(const LoadCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&GCMStoreImpl::Backend::Load, backend_, callback));
 }
 
-void RMQStore::Destroy(const UpdateCallback& callback) {
+void GCMStoreImpl::Destroy(const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::Destroy,
-                 backend_,
-                 callback));
+      base::Bind(&GCMStoreImpl::Backend::Destroy, backend_, callback));
 }
 
-void RMQStore::SetDeviceCredentials(uint64 device_android_id,
-                                    uint64 device_security_token,
-                                    const UpdateCallback& callback) {
+void GCMStoreImpl::SetDeviceCredentials(uint64 device_android_id,
+                                        uint64 device_security_token,
+                                        const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::SetDeviceCredentials,
+      base::Bind(&GCMStoreImpl::Backend::SetDeviceCredentials,
                  backend_,
                  device_android_id,
                  device_security_token,
                  callback));
 }
 
-void RMQStore::AddIncomingMessage(const std::string& persistent_id,
-                                  const UpdateCallback& callback) {
+void GCMStoreImpl::AddIncomingMessage(const std::string& persistent_id,
+                                      const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::AddIncomingMessage,
+      base::Bind(&GCMStoreImpl::Backend::AddIncomingMessage,
                  backend_,
                  persistent_id,
                  callback));
 }
 
-void RMQStore::RemoveIncomingMessage(const std::string& persistent_id,
-                                     const UpdateCallback& callback) {
+void GCMStoreImpl::RemoveIncomingMessage(const std::string& persistent_id,
+                                         const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::RemoveIncomingMessages,
+      base::Bind(&GCMStoreImpl::Backend::RemoveIncomingMessages,
                  backend_,
                  PersistentIdList(1, persistent_id),
                  callback));
 }
 
-void RMQStore::RemoveIncomingMessages(const PersistentIdList& persistent_ids,
-                                      const UpdateCallback& callback) {
+void GCMStoreImpl::RemoveIncomingMessages(
+    const PersistentIdList& persistent_ids,
+    const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::RemoveIncomingMessages,
+      base::Bind(&GCMStoreImpl::Backend::RemoveIncomingMessages,
                  backend_,
                  persistent_ids,
                  callback));
 }
 
-void RMQStore::AddOutgoingMessage(const std::string& persistent_id,
-                                  const MCSMessage& message,
-                                  const UpdateCallback& callback) {
+void GCMStoreImpl::AddOutgoingMessage(const std::string& persistent_id,
+                                      const MCSMessage& message,
+                                      const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::AddOutgoingMessage,
+      base::Bind(&GCMStoreImpl::Backend::AddOutgoingMessage,
                  backend_,
                  persistent_id,
                  message,
                  callback));
 }
 
-void RMQStore::RemoveOutgoingMessage(const std::string& persistent_id,
-                                     const UpdateCallback& callback) {
+void GCMStoreImpl::RemoveOutgoingMessage(const std::string& persistent_id,
+                                         const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::RemoveOutgoingMessages,
+      base::Bind(&GCMStoreImpl::Backend::RemoveOutgoingMessages,
                  backend_,
                  PersistentIdList(1, persistent_id),
                  callback));
 }
 
-void RMQStore::RemoveOutgoingMessages(const PersistentIdList& persistent_ids,
-                                      const UpdateCallback& callback) {
+void GCMStoreImpl::RemoveOutgoingMessages(
+    const PersistentIdList& persistent_ids,
+    const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::RemoveOutgoingMessages,
+      base::Bind(&GCMStoreImpl::Backend::RemoveOutgoingMessages,
                  backend_,
                  persistent_ids,
                  callback));
 }
 
-void RMQStore::SetNextSerialNumber(int64 next_serial_number,
-                                   const UpdateCallback& callback) {
+void GCMStoreImpl::SetNextSerialNumber(int64 next_serial_number,
+                                       const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::SetNextSerialNumber,
+      base::Bind(&GCMStoreImpl::Backend::SetNextSerialNumber,
                  backend_,
                  next_serial_number,
                  callback));
 }
 
-void RMQStore::AddUserSerialNumber(const std::string& username,
-                                   int64 serial_number,
-                                   const UpdateCallback& callback) {
+void GCMStoreImpl::AddUserSerialNumber(const std::string& username,
+                                       int64 serial_number,
+                                       const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::AddUserSerialNumber,
+      base::Bind(&GCMStoreImpl::Backend::AddUserSerialNumber,
                  backend_,
                  username,
                  serial_number,
                  callback));
 }
 
-void RMQStore::RemoveUserSerialNumber(const std::string& username,
-                                      const UpdateCallback& callback) {
+void GCMStoreImpl::RemoveUserSerialNumber(const std::string& username,
+                                          const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RMQStore::Backend::RemoveUserSerialNumber,
+      base::Bind(&GCMStoreImpl::Backend::RemoveUserSerialNumber,
                  backend_,
                  username,
                  callback));