sync: Add location info to unrecoverable error.

chrome/browser/sync/glue/preference_change_processor.cc

 // Copyright (c) 2006-2009 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/glue/preference_change_processor.h"
 
 #include <set>
 #include <string>
 
 #include "base/json/json_reader.h"
@@ skipping 43 matching lines @@
 
   // Do not pollute sync data with values coming from policy.
   if (preference->IsManaged())
     return;
 
   sync_api::WriteTransaction trans(share_handle());
   sync_api::WriteNode node(&trans);
 
   int64 sync_id = model_associator_->GetSyncIdFromChromeId(*name);
   if (sync_api::kInvalidId == sync_id) {
-    LOG(ERROR) << "Unexpected notification for: " << *name;
-    error_handler()->OnUnrecoverableError();
+    std::wstring err = L"Unexpected notification for: " + *name;
+    error_handler()->OnUnrecoverableError(FROM_HERE, WideToUTF8(err));
     return;
   } else {
     if (!node.InitByIdLookup(sync_id)) {
-      LOG(ERROR) << "Preference node lookup failed.";
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+                                            "Preference node lookup failed.");
       return;
     }
   }
 
   if (!WritePreference(&node, *name, preference->GetValue())) {
-    LOG(ERROR) << "Failed to update preference node.";
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+                                          "Failed to update preference node.");
     return;
   }
 }
 
 void PreferenceChangeProcessor::ApplyChangesFromSyncModel(
     const sync_api::BaseTransaction* trans,
     const sync_api::SyncManager::ChangeRecord* changes,
     int change_count) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   if (!running())
     return;
   StopObserving();
 
   for (int i = 0; i < change_count; ++i) {
     sync_api::ReadNode node(trans);
     // TODO(ncarter): Can't look up the name for deletions: lookup of
     // deleted items fails at the syncapi layer.  However, the node should
     // generally still exist in the syncable database; we just need to
     // plumb the syncapi so that it succeeds.
     if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE ==
         changes[i].action) {
       // Until the above is fixed, we have no choice but to ignore deletions.
       LOG(ERROR) << "No way to handle pref deletion";
       continue;
     }
 
     if (!node.InitByIdLookup(changes[i].id)) {
-      LOG(ERROR) << "Preference node lookup failed.";
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+                                            "Preference node lookup failed.");
       return;
     }
     DCHECK(syncable::PREFERENCES == node.GetModelType());
 
     std::wstring name;
     scoped_ptr<Value> value(ReadPreference(&node, &name));
     // Skip values we can't deserialize.
     if (!value.get())
       continue;
 
@@ skipping 30 matching lines @@
   StartObserving();
 }
 
 bool PreferenceChangeProcessor::WritePreference(
     sync_api::WriteNode* node,
     const std::wstring& name,
     const Value* value) {
   std::string serialized;
   JSONStringValueSerializer json(&serialized);
   if (!json.Serialize(*value)) {
-    LOG(ERROR) << "Failed to serialize preference value.";
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+        "Failed to serialize preference value.");
     return false;
   }
 
   sync_pb::PreferenceSpecifics preference;
   preference.set_name(WideToUTF8(name));
   preference.set_value(serialized);
   node->SetPreferenceSpecifics(preference);
   node->SetTitle(name);
   return true;
 }
 
 Value* PreferenceChangeProcessor::ReadPreference(
     sync_api::ReadNode* node,
     std::wstring* name) {
   const sync_pb::PreferenceSpecifics& preference(
       node->GetPreferenceSpecifics());
   base::JSONReader reader;
   scoped_ptr<Value> value(reader.JsonToValue(preference.value(), false, false));
   if (!value.get()) {
-    LOG(ERROR) << "Failed to deserialize preference value: "
-               << reader.GetErrorMessage();
-    error_handler()->OnUnrecoverableError();
+    std::string err = "Failed to deserialize preference value: " +
+        reader.GetErrorMessage();
+    error_handler()->OnUnrecoverableError(FROM_HERE, err);
     return NULL;
   }
   *name = UTF8ToWide(preference.name());
   return value.release();
 }
 
 void PreferenceChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   pref_service_ = profile->GetPrefs();
   StartObserving();
@@ skipping 18 matching lines @@
 void PreferenceChangeProcessor::StopObserving() {
   DCHECK(pref_service_);
   for (std::set<std::wstring>::const_iterator it =
       model_associator_->synced_preferences().begin();
       it != model_associator_->synced_preferences().end(); ++it) {
     pref_service_->RemovePrefObserver((*it).c_str(), this);
   }
 }
 
 }  // namespace browser_sync