Renaming RMQStore to GCMStore and breaking out its interface

google_apis/gcm/engine/gcm_store_impl.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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 "google_apis/gcm/engine/rmq_store.h"
+#include "google_apis/gcm/engine/gcm_store_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 57 matching lines @@
 std::string ParseUsername(const std::string& key) {
   return key.substr(arraysize(kUserSerialNumberKeyStart) - 1);
 }
 
 leveldb::Slice MakeSlice(const base::StringPiece& s) {
   return leveldb::Slice(s.begin(), s.size());
 }
 
 }  // 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,
                             uint64 device_security_token,
                             const UpdateCallback& callback);
   void AddIncomingMessage(const std::string& persistent_id,
                           const UpdateCallback& callback);
   void RemoveIncomingMessages(const PersistentIdList& persistent_ids,
                               const UpdateCallback& callback);
   void AddOutgoingMessage(const std::string& persistent_id,
@@ skipping 19 matching lines @@
   bool LoadNextSerialNumber(int64* next_serial_number);
   bool LoadUserSerialNumberMap(
       std::map<std::string, int64>* user_serial_number_map);
 
   const base::FilePath path_;
   scoped_refptr<base::SequencedTaskRunner> foreground_task_runner_;
 
   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);
 
   if (!LoadDeviceCredentials(&result.device_android_id,
                              &result.device_security_token) ||
       !LoadIncomingMessages(&result.incoming_messages) ||
       !LoadOutgoingMessages(&result.outgoing_messages) ||
       !LoadNextSerialNumber(&result.next_serial_number) ||
       !LoadUserSerialNumberMap(&result.user_serial_numbers)) {
     result.device_android_id = 0;
     result.device_security_token = 0;
     result.incoming_messages.clear();
     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;
 
   std::string encrypted_token;
   Encryptor::EncryptString(base::Uint64ToString(device_security_token),
                            &encrypted_token);
   leveldb::Status s =
       db_->Put(write_options,
                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;
   write_options.sync = true;
 
   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;
   write_options.sync = true;
 
   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;
 
   const leveldb::Status status =
       db_->Put(write_options,
                MakeSlice(MakeUserSerialNumberKey(username)),
                MakeSlice(base::Int64ToString(serial_number)));
   if (status.ok()) {
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB put failed: " << status.ToString();
   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;
 
   leveldb::Status status = db_->Delete(write_options, MakeSlice(username));
   if (status.ok()) {
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB remove failed: " << status.ToString();
   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;
   write_options.sync = true;
 
   const leveldb::Status status =
       db_->Put(write_options,
                MakeSlice(kNextSerialNumberKey),
                MakeSlice(base::Int64ToString(next_serial_number)));
   if (status.ok()) {
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "LevelDB put failed: " << status.ToString();
   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;
     Encryptor::DecryptString(result, &decrypted_token);
     if (!base::StringToUint64(decrypted_token, security_token)) {
       LOG(ERROR) << "Failed to restore security token.";
       return false;
     }
     return true;
   }
 
   if (s.IsNotFound()) {
     DVLOG(1) << "No credentials found.";
     return true;
   }
 
   LOG(ERROR) << "Error reading credentials from store.";
   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;
 
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kIncomingMsgKeyStart));
        iter->Valid() && iter->key().ToString() < kIncomingMsgKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.empty()) {
       LOG(ERROR) << "Error reading incoming message with key "
                  << iter->key().ToString();
       return false;
     }
     DVLOG(1) << "Found incoming message with id " << s.ToString();
     incoming_messages->push_back(s.ToString());
   }
 
   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;
 
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kOutgoingMsgKeyStart));
        iter->Valid() && iter->key().ToString() < kOutgoingMsgKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading incoming message with key " << s.ToString();
       return false;
     }
     uint8 tag = iter->value().data()[0];
     std::string id = ParseOutgoingKey(iter->key().ToString());
     scoped_ptr<google::protobuf::MessageLite> message(
         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 "
              << base::IntToString(tag);
     (*outgoing_messages)[id] = message.release();
   }
 
   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.";
       return false;
     }
     return true;
   }
 
   if (status.IsNotFound()) {
     DVLOG(1) << "No next serial number found.";
     return true;
   }
 
   LOG(ERROR) << "Error when reading the 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;
 
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kUserSerialNumberKeyStart));
        iter->Valid() && iter->key().ToString() < kUserSerialNumberKeyEnd;
        iter->Next()) {
     std::string username = ParseUsername(iter->key().ToString());
     if (username.empty()) {
       LOG(ERROR) << "Error reading username. It should not be empty.";
       return false;
     }
     std::string serial_number_string = iter->value().ToString();
     int64 serial_number = kSerialNumberMissing;
     if (!base::StringToInt64(serial_number_string, &serial_number)) {
       LOG(ERROR) << "Error reading user serial number for user: " << username;
       return false;
     }
 
     (*user_serial_number_map)[username] = serial_number;
   }
 
   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) {
+      blocking_task_runner_(blocking_task_runner) {}
+
+GCMStoreImpl::~GCMStoreImpl() {}
+
+void GCMStoreImpl::Load(const LoadCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&GCMStoreImpl::Backend::Load, backend_, callback));
 }
 
-RMQStore::~RMQStore() {
+void GCMStoreImpl::Destroy(const UpdateCallback& callback) {
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMStoreImpl::Backend::Destroy, backend_, callback));
 }
 
-void RMQStore::Load(const LoadCallback& callback) {
-  blocking_task_runner_->PostTask(FROM_HERE,
-                                  base::Bind(&RMQStore::Backend::Load,
-                                             backend_,
-                                             callback));
-}
-
-void RMQStore::Destroy(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::Destroy,
-                 backend_,
-                 callback));
-}
-
-void RMQStore::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));
 }
 
 }  // namespace gcm