[Tango->FCM] Separate status enum for Fcm channel.

Currently fcm channel and subscription to topics use same enum in order to track their
state. This Cl introduces separate enum for the Fcm channel state tracking.

Bug: 801985, 878446

Change-Id: I4a462414852d9bc77c45da125c2a0598afffa8e0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1502912
Commit-Queue: Tatiana Gornak <melandory@chromium.org>
Reviewed-by: Jan Krcal <jkrcal@chromium.org>
Cr-Commit-Position: refs/heads/master@{#637835}

components/invalidation/impl/BUILD.gn

@@ -19,6 +19,8 @@ static_library("feature_list") {
 
 static_library("impl") {
   sources = [
+    "channels_states.cc",
+    "channels_states.h",
     "deprecated_invalidator_registrar.cc",
     "deprecated_invalidator_registrar.h",
     "fcm_invalidation_listener.cc",

components/invalidation/impl/channels_states.cc

+// Copyright 2019 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/invalidation/impl/channels_states.h"
+
+namespace syncer {
+
+const char* FcmChannelStateToString(FcmChannelState state) {
+  switch (state) {
+    case FcmChannelState::NOT_STARTED:
+      return "NOT_STARTED";
+    case FcmChannelState::ENABLED:
+      return "ENABLED";
+    case FcmChannelState::NO_INSTANCE_ID_TOKEN:
+      return "NO_INSTANCE_ID_TOKEN";
+  }
+}
+
+}  // namespace syncer

components/invalidation/impl/channels_states.h

+// Copyright 2019 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.
+
+#ifndef COMPONENTS_INVALIDATION_IMPL_CHANNELS_STATES_H_
+#define COMPONENTS_INVALIDATION_IMPL_CHANNELS_STATES_H_
+
+namespace syncer {
+
+enum class FcmChannelState {
+  NOT_STARTED,
+  // Fcm network channel is working properly.
+  ENABLED,
+  // Failed to retrieve instance id token.
+  NO_INSTANCE_ID_TOKEN,
+
+  kMaxValue = NO_INSTANCE_ID_TOKEN,
+};
+
+const char* FcmChannelStateToString(FcmChannelState state);
+
+}  // namespace syncer
+
+#endif  // COMPONENTS_INVALIDATION_IMPL_CHANNELS_STATES_H_

components/invalidation/impl/fcm_invalidation_listener.cc

@@ -23,8 +23,6 @@ FCMInvalidationListener::FCMInvalidationListener(
     std::unique_ptr<FCMSyncNetworkChannel> network_channel)
     : network_channel_(std::move(network_channel)),
       delegate_(nullptr),
-      subscription_channel_state_(DEFAULT_INVALIDATION_ERROR),
-      fcm_network_state_(DEFAULT_INVALIDATION_ERROR),
       weak_factory_(this) {
   network_channel_->AddObserver(this);
 }
@@ -202,18 +200,17 @@ void FCMInvalidationListener::Stop() {
   per_user_topic_registration_manager_.reset();
 
   subscription_channel_state_ = DEFAULT_INVALIDATION_ERROR;
-  fcm_network_state_ = DEFAULT_INVALIDATION_ERROR;
+  fcm_network_state_ = FcmChannelState::NOT_STARTED;
 }
 
 InvalidatorState FCMInvalidationListener::GetState() const {
-  if (subscription_channel_state_ == INVALIDATION_CREDENTIALS_REJECTED ||
-      fcm_network_state_ == INVALIDATION_CREDENTIALS_REJECTED) {
+  if (subscription_channel_state_ == INVALIDATION_CREDENTIALS_REJECTED) {
     // If either the ticl or the push client rejected our credentials,
     // return INVALIDATION_CREDENTIALS_REJECTED.
     return INVALIDATION_CREDENTIALS_REJECTED;
   }
   if (subscription_channel_state_ == INVALIDATIONS_ENABLED &&
-      fcm_network_state_ == INVALIDATIONS_ENABLED) {
+      fcm_network_state_ == FcmChannelState::ENABLED) {
     // If the ticl is ready and the push client notifications are
     // enabled, return INVALIDATIONS_ENABLED.
     return INVALIDATIONS_ENABLED;
@@ -229,9 +226,8 @@ void FCMInvalidationListener::EmitStateChange() {
   delegate_->OnInvalidatorStateChange(GetState());
 }
 
-void FCMInvalidationListener::OnFCMSyncNetworkChannelStateChanged(
-    InvalidatorState invalidator_state) {
-  fcm_network_state_ = invalidator_state;
+void FCMInvalidationListener::OnFCMChannelStateChanged(FcmChannelState state) {
+  fcm_network_state_ = state;
   EmitStateChange();
 }
 
@@ -245,7 +241,7 @@ base::DictionaryValue FCMInvalidationListener::CollectDebugData() const {
   base::DictionaryValue status =
       per_user_topic_registration_manager_->CollectDebugData();
   status.SetString("InvalidationListener.FCM-channel-state",
-                   InvalidatorStateToString(fcm_network_state_));
+                   FcmChannelStateToString(fcm_network_state_));
   status.SetString("InvalidationListener.Subscription-channel-state",
                    InvalidatorStateToString(subscription_channel_state_));
   for (const Topic& topic : registered_topics_) {

components/invalidation/impl/fcm_invalidation_listener.h

@@ -10,6 +10,7 @@
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "components/invalidation/impl/channels_states.h"
 #include "components/invalidation/impl/fcm_sync_network_channel.h"
 #include "components/invalidation/impl/invalidation_client.h"
 #include "components/invalidation/impl/invalidation_listener.h"
@@ -82,8 +83,7 @@ class FCMInvalidationListener : public InvalidationListener,
             const syncer::AckHandle& handle) override;
 
   // FCMSyncNetworkChannel::Observer implementation.
-  void OnFCMSyncNetworkChannelStateChanged(
-      InvalidatorState invalidator_state) override;
+  void OnFCMChannelStateChanged(FcmChannelState state) override;
 
   // PerUserTopicRegistrationManager::Observer implementation.
   void OnSubscriptionChannelStateChanged(
@@ -139,8 +139,8 @@ class FCMInvalidationListener : public InvalidationListener,
   TopicSet registered_topics_;
 
   // The states of the HTTP and FCM channel.
-  InvalidatorState subscription_channel_state_;
-  InvalidatorState fcm_network_state_;
+  InvalidatorState subscription_channel_state_ = DEFAULT_INVALIDATION_ERROR;
+  FcmChannelState fcm_network_state_ = FcmChannelState::NOT_STARTED;
 
   std::unique_ptr<PerUserTopicRegistrationManager>
       per_user_topic_registration_manager_;

components/invalidation/impl/fcm_invalidation_listener_unittest.cc

@@ -301,11 +301,12 @@ class FCMInvalidationListenerTest : public testing::Test {
   }
 
   void EnableNotifications() {
-    fcm_sync_network_channel_->NotifyChannelStateChange(INVALIDATIONS_ENABLED);
+    fcm_sync_network_channel_->NotifyChannelStateChange(
+        FcmChannelState::ENABLED);
     listener_.InformTokenRecieved(fake_invalidation_client_, "token");
   }
 
-  void DisableNotifications(InvalidatorState state) {
+  void DisableNotifications(FcmChannelState state) {
     fcm_sync_network_channel_->NotifyChannelStateChange(state);
   }
 
@@ -478,7 +479,7 @@ TEST_F(FCMInvalidationListenerTest, InvalidateMultipleIds) {
 TEST_F(FCMInvalidationListenerTest, EnableNotificationsNotReady) {
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, GetInvalidatorState());
 
-  DisableNotifications(TRANSIENT_INVALIDATION_ERROR);
+  DisableNotifications(FcmChannelState::NOT_STARTED);
 
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, GetInvalidatorState());
 
@@ -516,17 +517,17 @@ TEST_F(FCMInvalidationListenerTest, ReadyThenEnableNotifications) {
 }
 
 // Enable notifications and ready the client.  Then disable
-// notifications with an auth error and re-enable notifications.  The
-// delegate should go into an auth error mode and then back out.
-TEST_F(FCMInvalidationListenerTest, PushClientAuthError) {
+// notifications with no_token error.  The delegate should
+// go into an error and then back out.
+TEST_F(FCMInvalidationListenerTest, FcmChannelNoTokenError) {
   EnableNotifications();
   listener_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(INVALIDATIONS_ENABLED, GetInvalidatorState());
 
-  DisableNotifications(INVALIDATION_CREDENTIALS_REJECTED);
+  DisableNotifications(FcmChannelState::NO_INSTANCE_ID_TOKEN);
 
-  EXPECT_EQ(INVALIDATION_CREDENTIALS_REJECTED, GetInvalidatorState());
+  EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, GetInvalidatorState());
 
   EnableNotifications();
 

components/invalidation/impl/fcm_network_handler.cc

@@ -128,7 +128,7 @@ void FCMNetworkHandler::DidRetrieveToken(const std::string& subscription_token,
       // validation.
       DeliverToken(subscription_token);
       token_ = subscription_token;
-      UpdateGcmChannelState(/* online */ true);
+      UpdateChannelState(FcmChannelState::ENABLED);
       break;
     case InstanceID::INVALID_PARAMETER:
     case InstanceID::DISABLED:
@@ -138,7 +138,7 @@ void FCMNetworkHandler::DidRetrieveToken(const std::string& subscription_token,
     case InstanceID::NETWORK_ERROR:
       DLOG(WARNING) << "Messaging subscription failed; InstanceID::Result = "
                     << result;
-      UpdateGcmChannelState(/* online */ false);
+      UpdateChannelState(FcmChannelState::NO_INSTANCE_ID_TOKEN);
       break;
   }
   ScheduleNextTokenValidation();
@@ -178,6 +178,7 @@ void FCMNetworkHandler::DidReceiveTokenForValidation(
   diagnostic_info_.instance_id_token_verified = base::Time::Now();
   diagnostic_info_.token_verification_result = result;
   if (result == InstanceID::SUCCESS) {
+    UpdateChannelState(FcmChannelState::ENABLED);
     if (token_ != new_token) {
       diagnostic_info_.token_changed = true;
       token_ = new_token;
@@ -188,12 +189,11 @@ void FCMNetworkHandler::DidReceiveTokenForValidation(
   ScheduleNextTokenValidation();
 }
 
-void FCMNetworkHandler::UpdateGcmChannelState(bool online) {
-  if (gcm_channel_online_ == online)
+void FCMNetworkHandler::UpdateChannelState(FcmChannelState state) {
+  if (channel_state_ == state)
     return;
-  gcm_channel_online_ = online;
-  NotifyChannelStateChange(gcm_channel_online_ ? INVALIDATIONS_ENABLED
-                                               : TRANSIENT_INVALIDATION_ERROR);
+  channel_state_ = state;
+  NotifyChannelStateChange(channel_state_);
 }
 
 void FCMNetworkHandler::ShutdownHandler() {}

components/invalidation/impl/fcm_network_handler.h

@@ -10,6 +10,7 @@
 #include "base/timer/timer.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 #include "components/gcm_driver/instance_id/instance_id.h"
+#include "components/invalidation/impl/channels_states.h"
 #include "components/invalidation/impl/fcm_sync_network_channel.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ -68,7 +69,7 @@ class FCMNetworkHandler : public gcm::GCMAppHandler,
   void StartListening();
   void StopListening();
   bool IsListening() const;
-  void UpdateGcmChannelState(bool);
+  void UpdateChannelState(FcmChannelState state);
 
   // GCMAppHandler overrides.
   void ShutdownHandler() override;
@@ -100,7 +101,7 @@ class FCMNetworkHandler : public gcm::GCMAppHandler,
   gcm::GCMDriver* const gcm_driver_;
   instance_id::InstanceIDDriver* const instance_id_driver_;
 
-  bool gcm_channel_online_ = false;
+  FcmChannelState channel_state_ = FcmChannelState::NOT_STARTED;
   std::string token_;
 
   std::unique_ptr<base::OneShotTimer> token_validation_timer_;

components/invalidation/impl/fcm_sync_network_channel.cc

@@ -29,10 +29,9 @@ void FCMSyncNetworkChannel::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void FCMSyncNetworkChannel::NotifyChannelStateChange(
-    InvalidatorState invalidator_state) {
+void FCMSyncNetworkChannel::NotifyChannelStateChange(FcmChannelState state) {
   for (auto& observer : observers_)
-    observer.OnFCMSyncNetworkChannelStateChanged(invalidator_state);
+    observer.OnFCMChannelStateChanged(state);
 }
 
 bool FCMSyncNetworkChannel::DeliverIncomingMessage(

components/invalidation/impl/fcm_sync_network_channel.h

@@ -11,8 +11,8 @@
 #include "base/callback.h"
 #include "base/observer_list.h"
 #include "base/values.h"
+#include "components/invalidation/impl/channels_states.h"
 #include "components/invalidation/impl/network_channel.h"
-#include "components/invalidation/public/invalidator_state.h"
 
 namespace syncer {
 
@@ -24,8 +24,8 @@ class FCMSyncNetworkChannel : public NetworkChannel {
  public:
   class Observer {
    public:
-    virtual void OnFCMSyncNetworkChannelStateChanged(
-        InvalidatorState invalidator_state) = 0;
+    virtual void OnFCMChannelStateChanged(
+        FcmChannelState invalidator_state) = 0;
   };
 
   FCMSyncNetworkChannel();
@@ -51,7 +51,7 @@ class FCMSyncNetworkChannel : public NetworkChannel {
   // NotifyChannelStateChange. If communication doesn't work and it is possible
   // that invalidations from server will not reach this client then channel
   // should call this function with TRANSIENT_INVALIDATION_ERROR.
-  void NotifyChannelStateChange(InvalidatorState invalidator_state);
+  void NotifyChannelStateChange(FcmChannelState invalidator_state);
 
   // Subclass should call DeliverIncomingMessage for message to reach
   // invalidations library.