[Sync] Print out notification state explicitly in about:sync

sync/internal_api/sync_manager_impl.cc

 // Copyright (c) 2012 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 "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 22 matching lines @@
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/internal_api/syncapi_server_connection_manager.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_event_handler.h"
 #include "sync/js/js_reply_handler.h"
 #include "sync/notifier/invalidation_util.h"
-#include "sync/notifier/notifications_disabled_reason.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/protocol/proto_value_conversions.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
 #include "sync/syncable/nigori_util.h"
 #include "sync/syncable/on_disk_directory_backing_store.h"
 #include "sync/util/get_session_name.h"
@@ skipping 114 matching lines @@
     return delay;
   }
 };
 
 SyncManagerImpl::SyncManagerImpl(const std::string& name)
     : name_(name),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       change_delegate_(NULL),
       initialized_(false),
       observing_ip_address_changes_(false),
+      notifications_disabled_reason_(TRANSIENT_NOTIFICATION_ERROR),
       throttled_data_type_tracker_(&allstatus_),
       traffic_recorder_(kMaxMessagesToRecord, kMaxMessageSizeToRecord),
       encryptor_(NULL),
       unrecoverable_error_handler_(NULL),
       report_unrecoverable_error_function_(NULL),
       nigori_overwrite_count_(0) {
   // Pre-fill |notification_info_map_|.
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     notification_info_map_.insert(
         std::make_pair(ModelTypeFromInt(i), NotificationInfo()));
@@ skipping 1420 matching lines @@
                      name, js_message_handler.Run(args));
 }
 
 void SyncManagerImpl::BindJsMessageHandler(
     const std::string& name,
     UnboundJsMessageHandler unbound_message_handler) {
   js_message_handlers_[name] =
       base::Bind(unbound_message_handler, base::Unretained(this));
 }
 
+void SyncManagerImpl::OnNotificationStateChange(
+    NotificationsDisabledReason reason) {
+  const std::string& reason_str = NotificationsDisabledReasonToString(reason);
+  notifications_disabled_reason_ = reason;
+  DVLOG(1) << "Notification state changed to: " << reason_str;
+  const bool notifications_enabled =
+      (notifications_disabled_reason_ == NO_NOTIFICATION_ERROR);
+  allstatus_.SetNotificationsEnabled(notifications_enabled);
+  scheduler_->SetNotificationsEnabled(notifications_enabled);
+
+  // TODO(akalin): Treat a CREDENTIALS_REJECTED state as an auth
+  // error.
+
+  if (js_event_handler_.IsInitialized()) {
+    DictionaryValue details;
+    details.Set("state", Value::CreateStringValue(reason_str));
+    js_event_handler_.Call(FROM_HERE,
+                           &JsEventHandler::HandleJsEvent,
+                           "onNotificationStateChange",
+                           JsEventDetails(&details));
+  }
+}
+
 DictionaryValue* SyncManagerImpl::NotificationInfoToValue(
     const NotificationInfoMap& notification_info) {
   DictionaryValue* value = new DictionaryValue();
 
   for (NotificationInfoMap::const_iterator it = notification_info.begin();
       it != notification_info.end(); ++it) {
     const std::string& model_type_str = ModelTypeToString(it->first);
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
+std::string SyncManagerImpl::NotificationInfoToString(
+    const NotificationInfoMap& notification_info) {
+  scoped_ptr<DictionaryValue> value(
+      NotificationInfoToValue(notification_info));
+  std::string str;
+  base::JSONWriter::Write(value.get(), &str);
+  return str;
+}
+
 JsArgList SyncManagerImpl::GetNotificationState(
     const JsArgList& args) {
-  bool notifications_enabled = allstatus_.status().notifications_enabled;
+  const std::string& notification_state =
+      NotificationsDisabledReasonToString(notifications_disabled_reason_);
+  DVLOG(1) << "GetNotificationState: " << notification_state;
   ListValue return_args;
-  return_args.Append(Value::CreateBooleanValue(notifications_enabled));
+  return_args.Append(Value::CreateStringValue(notification_state));
   return JsArgList(&return_args);
 }
 
 JsArgList SyncManagerImpl::GetNotificationInfo(
     const JsArgList& args) {
+  DVLOG(1) << "GetNotificationInfo: "
+           << NotificationInfoToString(notification_info_map_);
   ListValue return_args;
   return_args.Append(NotificationInfoToValue(notification_info_map_));
   return JsArgList(&return_args);
 }
 
 JsArgList SyncManagerImpl::GetRootNodeDetails(
     const JsArgList& args) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode root(&trans);
   root.InitByRootLookup();
@@ skipping 111 matching lines @@
     const ModelTypePayloadMap& type_payloads) {
   for (ModelTypePayloadMap::const_iterator it = type_payloads.begin();
        it != type_payloads.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
     info->payload = it->second;
   }
 }
 
 void SyncManagerImpl::OnNotificationsEnabled() {
-  DVLOG(1) << "Notifications enabled";
-  allstatus_.SetNotificationsEnabled(true);
-  scheduler_->SetNotificationsEnabled(true);
-
-  // TODO(akalin): Separate onNotificationStateChange into
-  // enabled/disabled events.
-  if (js_event_handler_.IsInitialized()) {
-    DictionaryValue details;
-    details.Set("enabled", Value::CreateBooleanValue(true));
-    js_event_handler_.Call(FROM_HERE,
-                           &JsEventHandler::HandleJsEvent,
-                           "onNotificationStateChange",
-                           JsEventDetails(&details));
-  }
+  OnNotificationStateChange(NO_NOTIFICATION_ERROR);
 }
 
 void SyncManagerImpl::OnNotificationsDisabled(
     NotificationsDisabledReason reason) {
-  DVLOG(1) << "Notifications disabled with reason "
-           << NotificationsDisabledReasonToString(reason);
-  allstatus_.SetNotificationsEnabled(false);
-  scheduler_->SetNotificationsEnabled(false);
-  if (js_event_handler_.IsInitialized()) {
-    DictionaryValue details;
-    details.Set("enabled", Value::CreateBooleanValue(false));
-    js_event_handler_.Call(FROM_HERE,
-                           &JsEventHandler::HandleJsEvent,
-                           "onNotificationStateChange",
-                           JsEventDetails(&details));
-  }
-  // TODO(akalin): Treat a CREDENTIALS_REJECTED state as an auth
-  // error.
+  OnNotificationStateChange(reason);
 }
 
 void SyncManagerImpl::OnIncomingNotification(
     const ObjectIdPayloadMap& id_payloads,
     IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const ModelTypePayloadMap& type_payloads =
       ObjectIdPayloadMapToModelTypePayloadMap(id_payloads);
   if (source == LOCAL_NOTIFICATION) {
     scheduler_->ScheduleNudgeWithPayloadsAsync(
@@ skipping 72 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer