Home | History | Annotate | Download | only in api 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "sync/api/sync_error.h"
      6 
      7 #include <ostream>
      8 
      9 #include "base/location.h"
     10 #include "base/logging.h"
     11 #include "sync/internal_api/public/base/model_type.h"
     12 
     13 namespace syncer {
     14 
     15 SyncError::SyncError() {
     16   Clear();
     17 }
     18 
     19 SyncError::SyncError(const tracked_objects::Location& location,
     20                      ErrorType error_type,
     21                      const std::string& message,
     22                      ModelType model_type) {
     23   DCHECK(error_type != UNSET);
     24   Init(location, message, model_type, error_type);
     25   PrintLogError();
     26 }
     27 
     28 SyncError::SyncError(const SyncError& other) {
     29   Copy(other);
     30 }
     31 
     32 SyncError::~SyncError() {
     33 }
     34 
     35 SyncError& SyncError::operator=(const SyncError& other) {
     36   if (this == &other) {
     37     return *this;
     38   }
     39   Copy(other);
     40   return *this;
     41 }
     42 
     43 void SyncError::Copy(const SyncError& other) {
     44   if (other.IsSet()) {
     45     Init(other.location(),
     46          other.message(),
     47          other.model_type(),
     48          other.error_type());
     49   } else {
     50     Clear();
     51   }
     52 }
     53 
     54 void SyncError::Clear() {
     55   location_.reset();
     56   message_ = std::string();
     57   model_type_ = UNSPECIFIED;
     58   error_type_ = UNSET;
     59 }
     60 
     61 void SyncError::Reset(const tracked_objects::Location& location,
     62                       const std::string& message,
     63                       ModelType model_type) {
     64   Init(location, message, model_type, DATATYPE_ERROR);
     65   PrintLogError();
     66 }
     67 
     68 void SyncError::Init(const tracked_objects::Location& location,
     69                      const std::string& message,
     70                      ModelType model_type,
     71                      ErrorType error_type) {
     72   location_.reset(new tracked_objects::Location(location));
     73   message_ = message;
     74   model_type_ = model_type;
     75   error_type_ = error_type;
     76 }
     77 
     78 bool SyncError::IsSet() const {
     79   return error_type_ != UNSET;
     80 }
     81 
     82 
     83 const tracked_objects::Location& SyncError::location() const {
     84   CHECK(IsSet());
     85   return *location_;
     86 }
     87 
     88 const std::string& SyncError::message() const {
     89   CHECK(IsSet());
     90   return message_;
     91 }
     92 
     93 ModelType SyncError::model_type() const {
     94   CHECK(IsSet());
     95   return model_type_;
     96 }
     97 
     98 SyncError::ErrorType SyncError::error_type() const {
     99   CHECK(IsSet());
    100   return error_type_;
    101 }
    102 
    103 SyncError::Severity SyncError::GetSeverity() const {
    104   switch (error_type_) {
    105     case UNREADY_ERROR:
    106     case DATATYPE_POLICY_ERROR:
    107       return SYNC_ERROR_SEVERITY_INFO;
    108     default:
    109       return SYNC_ERROR_SEVERITY_ERROR;
    110   }
    111 }
    112 
    113 std::string SyncError::GetMessagePrefix() const {
    114   std::string type_message;
    115   switch (error_type_) {
    116     case UNRECOVERABLE_ERROR:
    117       type_message = "unrecoverable error was encountered: ";
    118       break;
    119     case DATATYPE_ERROR:
    120       type_message = "datatype error was encountered: ";
    121       break;
    122     case PERSISTENCE_ERROR:
    123       type_message = "persistence error was encountered: ";
    124       break;
    125     case CRYPTO_ERROR:
    126       type_message = "cryptographer error was encountered: ";
    127       break;
    128     case UNREADY_ERROR:
    129       type_message = "unready error was encountered: ";
    130       break;
    131     case DATATYPE_POLICY_ERROR:
    132       type_message = "disabled due to configuration constraints: ";
    133       break;
    134     case UNSET:
    135       NOTREACHED() << "Invalid error type";
    136       break;
    137   }
    138   return type_message;
    139 }
    140 
    141 std::string SyncError::ToString() const {
    142   if (!IsSet()) {
    143     return std::string();
    144   }
    145   return location_->ToString() + ", " + ModelTypeToString(model_type_) +
    146       " " + GetMessagePrefix() + message_;
    147 }
    148 
    149 void SyncError::PrintLogError() const {
    150   logging::LogSeverity logSeverity =
    151       (GetSeverity() == SYNC_ERROR_SEVERITY_INFO)
    152           ? logging::LOG_VERBOSE : logging::LOG_ERROR;
    153 
    154   LAZY_STREAM(logging::LogMessage(location_->file_name(),
    155                                   location_->line_number(),
    156                                   logSeverity).stream(),
    157               logSeverity >= ::logging::GetMinLogLevel())
    158       << ModelTypeToString(model_type_) << " "
    159       << GetMessagePrefix() << message_;
    160 }
    161 
    162 void PrintTo(const SyncError& sync_error, std::ostream* os) {
    163   *os << sync_error.ToString();
    164 }
    165 
    166 }  // namespace syncer
    167