Keep the GCM data intact when the user signs out of the profile

components/gcm_driver/fake_gcm_client.cc

 // 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 "components/gcm_driver/fake_gcm_client.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "google_apis/gcm/base/encryptor.h"
 #include "google_apis/gcm/engine/account_mapping.h"
 #include "net/base/ip_endpoint.h"
 
 namespace gcm {
 
 FakeGCMClient::FakeGCMClient(
     StartMode start_mode,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread)
     : delegate_(NULL),
+      sequence_id_(0),
       status_(UNINITIALIZED),
       start_mode_(start_mode),
       ui_thread_(ui_thread),
       io_thread_(io_thread),
       weak_ptr_factory_(this) {
 }
 
 FakeGCMClient::~FakeGCMClient() {
 }
 
@@ skipping 27 matching lines @@
 
 void FakeGCMClient::Stop() {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   status_ = STOPPED;
   delegate_->OnDisconnected();
 }
 
 void FakeGCMClient::CheckOut() {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   status_ = CHECKED_OUT;
+  sequence_id_++;
 }
 
 void FakeGCMClient::Register(const std::string& app_id,
                              const std::vector<std::string>& sender_ids) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   std::string registration_id = GetRegistrationIdFromSenderIds(sender_ids);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMClient::RegisterFinished,
@@ skipping 69 matching lines @@
 void FakeGCMClient::DeleteMessages(const std::string& app_id) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMClient::MessagesDeleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  app_id));
 }
 
-// static
 std::string FakeGCMClient::GetRegistrationIdFromSenderIds(
-    const std::vector<std::string>& sender_ids) {
+    const std::vector<std::string>& sender_ids) const {
   // GCMService normalizes the sender IDs by making them sorted.
   std::vector<std::string> normalized_sender_ids = sender_ids;
   std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
 
   // Simulate the registration_id by concaternating all sender IDs.
   // Set registration_id to empty to denote an error if sender_ids contains a
   // hint.
   std::string registration_id;
   if (sender_ids.size() != 1 ||
       sender_ids[0].find("error") == std::string::npos) {
     for (size_t i = 0; i < normalized_sender_ids.size(); ++i) {
       if (i > 0)
         registration_id += ",";
       registration_id += normalized_sender_ids[i];
     }
+    registration_id += base::IntToString(sequence_id_);
   }
   return registration_id;
 }
 
 void FakeGCMClient::CheckinFinished() {
   delegate_->OnGCMReady(std::vector<AccountMapping>());
   delegate_->OnConnected(net::IPEndPoint());
 }
 
 void FakeGCMClient::RegisterFinished(const std::string& app_id,
@@ skipping 53 matching lines @@
     delegate_->OnMessageSendError(app_id, send_error_details);
 }
 
 void FakeGCMClient::SendAcknowledgement(const std::string& app_id,
                                         const std::string& message_id) {
   if (delegate_)
     delegate_->OnSendAcknowledged(app_id, message_id);
 }
 
 }  // namespace gcm