Notify GCMAppHandlers when the store is reset, so they clear cached IDs

components/invalidation/impl/gcm_invalidation_bridge.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 "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 25 matching lines @@
 // and passes all calls to GCMInvalidationBridge. All calls should be serialized
 // through GCMInvalidationBridge to avoid race conditions.
 class GCMInvalidationBridge::Core : public syncer::GCMNetworkChannelDelegate,
                                     public base::NonThreadSafe {
  public:
   Core(base::WeakPtr<GCMInvalidationBridge> bridge,
        scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner);
   ~Core() override;
 
   // syncer::GCMNetworkChannelDelegate implementation.
-  void Initialize(ConnectionStateCallback callback) override;
+  void Initialize(ConnectionStateCallback connection_state_callback,
+                  base::Closure store_reset_callback) override;
   void RequestToken(RequestTokenCallback callback) override;
   void InvalidateToken(const std::string& token) override;
   void Register(RegisterCallback callback) override;
   void SetMessageReceiver(MessageCallback callback) override;
 
   void RequestTokenFinished(RequestTokenCallback callback,
                             const GoogleServiceAuthError& error,
                             const std::string& token);
 
   void RegisterFinished(RegisterCallback callback,
                         const std::string& registration_id,
                         gcm::GCMClient::Result result);
 
   void OnIncomingMessage(const std::string& message,
                          const std::string& echo_token);
 
   void OnConnectionStateChanged(bool online);
+  void OnStoreReset();
 
  private:
   base::WeakPtr<GCMInvalidationBridge> bridge_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   MessageCallback message_callback_;
   ConnectionStateCallback connection_state_callback_;
+  base::Closure store_reset_callback_;
 
   base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 GCMInvalidationBridge::Core::Core(
     base::WeakPtr<GCMInvalidationBridge> bridge,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner)
     : bridge_(bridge),
       ui_thread_task_runner_(ui_thread_task_runner),
       weak_factory_(this) {
   // Core is created on UI thread but all calls happen on IO thread.
   DetachFromThread();
 }
 
 GCMInvalidationBridge::Core::~Core() {}
 
-void GCMInvalidationBridge::Core::Initialize(ConnectionStateCallback callback) {
+void GCMInvalidationBridge::Core::Initialize(
+    ConnectionStateCallback connection_state_callback,
+    base::Closure store_reset_callback) {
   DCHECK(CalledOnValidThread());
-  connection_state_callback_ = callback;
+  connection_state_callback_ = connection_state_callback;
+  store_reset_callback_ = store_reset_callback;
   // Pass core WeapPtr and TaskRunner to GCMInvalidationBridge for it to be able
   // to post back.
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::CoreInitializationDone,
                  bridge_,
                  weak_factory_.GetWeakPtr(),
                  base::ThreadTaskRunnerHandle::Get()));
 }
 
@@ skipping 48 matching lines @@
   DCHECK(!message_callback_.is_null());
   message_callback_.Run(message, echo_token);
 }
 
 void GCMInvalidationBridge::Core::OnConnectionStateChanged(bool online) {
   if (!connection_state_callback_.is_null()) {
     connection_state_callback_.Run(online);
   }
 }
 
+void GCMInvalidationBridge::Core::OnStoreReset() {
+  if (!store_reset_callback_.is_null()) {
+    store_reset_callback_.Run();
+  }
+}
+
 GCMInvalidationBridge::GCMInvalidationBridge(
     gcm::GCMDriver* gcm_driver,
     IdentityProvider* identity_provider)
     : OAuth2TokenService::Consumer("gcm_network_channel"),
       gcm_driver_(gcm_driver),
       identity_provider_(identity_provider),
       subscribed_for_incoming_messages_(false),
       weak_factory_(this) {}
 
 GCMInvalidationBridge::~GCMInvalidationBridge() {
@@ skipping 142 matching lines @@
                  core_,
                  gcm_driver_->IsConnected()));
 
   subscribed_for_incoming_messages_ = true;
 }
 
 void GCMInvalidationBridge::ShutdownHandler() {
   // Nothing to do.
 }
 
+void GCMInvalidationBridge::OnStoreReset() {
+  core_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&GCMInvalidationBridge::Core::OnStoreReset, core_));
+}
+
 void GCMInvalidationBridge::OnMessage(const std::string& app_id,
                                       const gcm::IncomingMessage& message) {
   gcm::MessageData::const_iterator it;
   std::string content;
   std::string echo_token;
   it = message.data.find(kContentKey);
   if (it != message.data.end())
     content = it->second;
   it = message.data.find(kEchoTokenKey);
   if (it != message.data.end())
@@ skipping 36 matching lines @@
 
 void GCMInvalidationBridge::OnDisconnected() {
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
                  core_,
                  false));
 }
 
 }  // namespace invalidation