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

sync/api/sync_error.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/api/sync_error.h"
 
 #include <ostream>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "sync/internal_api/public/base/model_type.h"
 
 namespace syncer {
 
 SyncError::SyncError() {
   Clear();
 }
 
 SyncError::SyncError(const tracked_objects::Location& location,
                      ErrorType error_type,
-                     const std::string& custom_message,
+                     const std::string& message,
                      ModelType model_type) {
-  std::string type_message;
-  switch (error_type) {
-    case UNRECOVERABLE_ERROR:
-      type_message = "unrecoverable error was encountered: ";
-      break;
-    case DATATYPE_ERROR:
-      type_message = "datatype error was encountered: ";
-      break;
-    case PERSISTENCE_ERROR:
-      type_message = "persistence error was encountered: ";
-      break;
-    case CRYPTO_ERROR:
-      type_message = "cryptographer error was encountered: ";
-      break;
-    case UNREADY_ERROR:
-      type_message = "unready error was encountered: ";
-      break;
-    case UNSET:
-      NOTREACHED() << "Invalid error type";
-      return;
-  }
-  Init(location, type_message + custom_message, model_type, error_type);
+  CHECK(error_type != UNSET);

[Nicolas Zea, 2014/07/14 17:36:02]

nit: prefer DCHECK vs CHECK, unless it's a security vulnerability or something
else that requires a crash (see
http://www.chromium.org/developers/coding-style). Also, I think you can use
DCHECK_NE(error_type, UNSET).

[stanisc, 2014/07/15 16:10:01]

Done.

+  Init(location, message, model_type, error_type);
   PrintLogError();
 }
 
 SyncError::SyncError(const SyncError& other) {
   Copy(other);
 }
 
 SyncError::~SyncError() {
 }
 
@@ skipping 58 matching lines @@
 ModelType SyncError::model_type() const {
   CHECK(IsSet());
   return model_type_;
 }
 
 SyncError::ErrorType SyncError::error_type() const {
   CHECK(IsSet());
   return error_type_;
 }
 
+logging::LogSeverity SyncError::severity() const {

[Nicolas Zea, 2014/07/14 17:36:02]

nit: accessors should do nothing more than access a variable (generally with the
same name as the function). This method and the one below have enough logic that
I think it's worth just calling them GetSeverity and GetTypeMessagePrefix.

[stanisc, 2014/07/15 16:10:01]

Done.

+  switch (error_type_) {
+    case UNREADY_ERROR:
+    case DATATYPE_POLICY_ERROR:
+      return logging::LOG_INFO;
+    default:
+      return logging::LOG_ERROR;
+  }
+}
+
+std::string SyncError::type_message_prefix() const {
+  std::string type_message;
+  switch (error_type_) {
+    case UNRECOVERABLE_ERROR:
+      type_message = "unrecoverable error was encountered: ";
+      break;
+    case DATATYPE_ERROR:
+      type_message = "datatype error was encountered: ";
+      break;
+    case PERSISTENCE_ERROR:
+      type_message = "persistence error was encountered: ";
+      break;
+    case CRYPTO_ERROR:
+      type_message = "cryptographer error was encountered: ";
+      break;
+    case UNREADY_ERROR:
+      type_message = "unready error was encountered: ";
+      break;
+    case DATATYPE_POLICY_ERROR:
+      type_message = "disabled due to configuration constraints: ";
+      break;
+    case UNSET:
+      NOTREACHED() << "Invalid error type";
+      break;
+  }
+  return type_message;
+}
+
 std::string SyncError::ToString() const {
   if (!IsSet()) {
     return std::string();
   }
   return location_->ToString() + ", " + ModelTypeToString(model_type_) +
-      " " + message_;
+      " " + type_message_prefix() + message_;
 }
 
 void SyncError::PrintLogError() const {
   LAZY_STREAM(logging::LogMessage(location_->file_name(),
                                   location_->line_number(),
-                                  logging::LOG_ERROR).stream(),
-              LOG_IS_ON(ERROR))
-      << ModelTypeToString(model_type_) << " " << message_;
+                                  severity()).stream(),
+              severity() >= ::logging::GetMinLogLevel())
+      << ModelTypeToString(model_type_) << " "
+      << type_message_prefix() << message_;
 }
 
 void PrintTo(const SyncError& sync_error, std::ostream* os) {
   *os << sync_error.ToString();
 }
 
 }  // namespace syncer