Sync: Display non-severe errors on about:sync in gray color rather than red.

chrome/browser/sync/profile_sync_service.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 "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 939 matching lines @@
                  delete_sync_database ?
                      browser_sync::SyncBackendHost::DISABLE_AND_CLAIM_THREAD :
                      browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD));
 }
 
 // TODO(zea): Move this logic into the DataTypeController/DataTypeManager.
 void ProfileSyncService::DisableDatatype(
     syncer::ModelType type,
     const tracked_objects::Location& from_here,
     std::string message) {
+  DisableDatatype(type, syncer::SyncError::DATATYPE_ERROR, from_here, message);
+}
+
+void ProfileSyncService::DisableDatatype(
+    syncer::ModelType type,
+    syncer::SyncError::ErrorType error_type,
+    const tracked_objects::Location& from_here,
+    std::string message) {
+  DCHECK(error_type == syncer::SyncError::DATATYPE_ERROR ||
+         error_type == syncer::SyncError::DATATYPE_POLICY_ERROR);
+
   // First deactivate the type so that no further server changes are
   // passed onto the change processor.
   DeactivateDataType(type);
 
-  syncer::SyncError error(from_here,
-                          syncer::SyncError::DATATYPE_ERROR,
-                          message,
-                          type);
+  syncer::SyncError error(from_here, error_type, message, type);
 
   std::map<syncer::ModelType, syncer::SyncError> errors;
   errors[type] = error;
 
   // Update this before posting a task. So if a configure happens before
   // the task that we are going to post, this type would still be disabled.
   failed_data_types_handler_.UpdateFailedDataTypes(errors);
 
   base::MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
@@ skipping 387 matching lines @@
            << syncer::ModelTypeSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
   DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
 
   // If sessions are encrypted, full history sync is not possible, and
   // delete directives are unnecessary.
   if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
       encrypted_types_.Has(syncer::SESSIONS)) {
     DisableDatatype(syncer::HISTORY_DELETE_DIRECTIVES,
+                    syncer::SyncError::DATATYPE_POLICY_ERROR,
                     FROM_HERE,
                     "Delete directives not supported with encryption.");
   }
 }
 
 void ProfileSyncService::OnEncryptionComplete() {
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
@@ skipping 388 matching lines @@
     return;
   }
 
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
   failed_data_types_handler_.Reset();
   if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
       encrypted_types_.Has(syncer::SESSIONS)) {
     DisableDatatype(syncer::HISTORY_DELETE_DIRECTIVES,
+                    syncer::SyncError::DATATYPE_POLICY_ERROR,
                     FROM_HERE,
                     "Delete directives not supported with encryption.");
   }
   ChangePreferredDataTypes(chosen_types);
   AcknowledgeSyncedTypes();
   NotifyObservers();
 }
 
 void ProfileSyncService::ChangePreferredDataTypes(
     syncer::ModelTypeSet preferred_types) {
@@ skipping 226 matching lines @@
   scoped_ptr<base::DictionaryValue> type_status;
   for (ModelTypeSet::Iterator it = registered.First(); it.Good(); it.Inc()) {
     ModelType type = it.Get();
 
     type_status.reset(new base::DictionaryValue());
     type_status->SetString("name", ModelTypeToString(type));
 
     if (error_map.find(type) != error_map.end()) {
       const syncer::SyncError &error = error_map.find(type)->second;
       DCHECK(error.IsSet());
-      std::string error_text = "Error: " + error.location().ToString() +
-          ", " + error.message();
-      type_status->SetString("status", "error");
-      type_status->SetString("value", error_text);
+      switch (error.severity()) {
+        case logging::LOG_ERROR: {
+            std::string error_text = "Error: " + error.location().ToString() +
+                ", " + error.type_message_prefix() + error.message();
+            type_status->SetString("status", "error");
+            type_status->SetString("value", error_text);
+          }
+          break;
+        case logging::LOG_INFO:
+          type_status->SetString("status", "disabled");
+          type_status->SetString("value", error.message());
+          break;
+        default:
+          NOTREACHED() << "Unexpected error severity.";
+          break;
+      }
     } else if (syncer::IsProxyType(type) && passive_types.Has(type)) {
       // Show a proxy type in "ok" state unless it is disabled by user.
       DCHECK(!throttled_types.Has(type));
       type_status->SetString("status", "ok");
       type_status->SetString("value", "Passive");
     } else if (throttled_types.Has(type) && passive_types.Has(type)) {
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Passive, Throttled");
     } else if (passive_types.Has(type)) {
       type_status->SetString("status", "warning");
@@ skipping 547 matching lines @@
   }
   return result;
 }
 
 void ProfileSyncService::StartStopBackupForTesting() {
   if (backend_mode_ == BACKUP)
     ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
   else
     backup_rollback_controller_.Start(base::TimeDelta());
 }