sync: Add location info to unrecoverable error.

chrome/browser/sync/glue/autofill_change_processor.cc

 // Copyright (c) 2010 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/autofill_change_processor.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_util.h"
@@ skipping 40 matching lines @@
     return;
 
   DCHECK(running());
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   if (!observing_)
     return;
 
   sync_api::WriteTransaction trans(share_handle());
   sync_api::ReadNode autofill_root(&trans);
   if (!autofill_root.InitByTagLookup(kAutofillTag)) {
-    error_handler()->OnUnrecoverableError();
-    LOG(ERROR) << "Server did not create the top-level autofill node. "
-        << "We might be running against an out-of-date server.";
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+        "Server did not create the top-level autofill node. "
+        "We might be running against an out-of-date server.");
     return;
   }
 
   switch (type.value) {
     case NotificationType::AUTOFILL_ENTRIES_CHANGED: {
       AutofillChangeList* changes = Details<AutofillChangeList>(details).ptr();
       ObserveAutofillEntriesChanged(changes, &trans, autofill_root);
       break;
     }
     case NotificationType::AUTOFILL_PROFILE_CHANGED: {
@@ skipping 11 matching lines @@
     sync_api::BaseTransaction* trans, AutoFillProfile* profile,
     std::string* tag) {
   DCHECK_EQ(AutofillModelAssociator::ProfileLabelToTag(profile->Label()),
                                                        *tag);
   sync_api::ReadNode read_node(trans);
   if (read_node.InitByClientTagLookup(syncable::AUTOFILL, *tag)) {
     // Handle the edge case of duplicate labels.
     string16 label(AutofillModelAssociator::MakeUniqueLabel(profile->Label(),
         trans));
     if (label.empty()) {
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+          "No unique label; can't move aside");
       return;
     }
     tag->assign(AutofillModelAssociator::ProfileLabelToTag(label));
 
     profile->set_label(label);
     if (!web_database_->UpdateAutoFillProfile(*profile)) {
-      LOG(ERROR) << "Failed to overwrite label for node" << label;
-      error_handler()->OnUnrecoverableError();
+      std::string err = "Failed to overwrite label for node ";
+      err += UTF16ToUTF8(label);
+      error_handler()->OnUnrecoverableError(FROM_HERE, err);
       return;
     }
 
     // Notify the PersonalDataManager that it's out of date.
     PostOptimisticRefreshTask();
   }
 }
 
 void AutofillChangeProcessor::PostOptimisticRefreshTask() {
   ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
       new AutofillModelAssociator::DoOptimisticRefreshTask(
            personal_data_));
 }
 
 void AutofillChangeProcessor::AddAutofillProfileSyncNode(
     sync_api::WriteTransaction* trans, const sync_api::BaseNode& autofill,
     const std::string& tag, const AutoFillProfile* profile) {
   sync_api::WriteNode sync_node(trans);
   if (!sync_node.InitUniqueByCreation(syncable::AUTOFILL, autofill, tag)) {
-    LOG(ERROR) << "Failed to create autofill sync node.";
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+        "Failed to create autofill sync node.");
     return;
   }
   sync_node.SetTitle(UTF8ToWide(tag));
 
   WriteAutofillProfile(*profile, &sync_node);
   model_associator_->Associate(&tag, sync_node.GetId());
 }
 
 void AutofillChangeProcessor::ObserveAutofillProfileChanged(
     AutofillProfileChange* change, sync_api::WriteTransaction* trans,
@@ skipping 18 matching lines @@
         RemoveSyncNode(AutofillModelAssociator::ProfileLabelToTag(
             change->pre_update_label()), trans);
         // Watch out! Could be relabelling to an existing label!
         HandleMoveAsideIfNeeded(trans, clone.get(), &tag);
         AddAutofillProfileSyncNode(trans, autofill_root, tag,
                                    clone.get());
         return;
       }
       int64 sync_id = model_associator_->GetSyncIdFromChromeId(tag);
       if (sync_api::kInvalidId == sync_id) {
-        LOG(ERROR) << "Unexpected notification for: " << tag;
-        error_handler()->OnUnrecoverableError();
+        std::string err = "Unexpected notification for: " + tag;
+        error_handler()->OnUnrecoverableError(FROM_HERE, err);
         return;
       } else {
         if (!sync_node.InitByIdLookup(sync_id)) {
-          LOG(ERROR) << "Autofill node lookup failed.";
-          error_handler()->OnUnrecoverableError();
+          error_handler()->OnUnrecoverableError(FROM_HERE,
+              "Autofill node lookup failed.");
           return;
         }
         WriteAutofillProfile(*change->profile(), &sync_node);
       }
       break;
     }
     case AutofillProfileChange::REMOVE: {
       RemoveSyncNode(tag, trans);
       break;
     }
   }
 }
 
 void AutofillChangeProcessor::ObserveAutofillEntriesChanged(
     AutofillChangeList* changes, sync_api::WriteTransaction* trans,
     const sync_api::ReadNode& autofill_root) {
   for (AutofillChangeList::iterator change = changes->begin();
        change != changes->end(); ++change) {
     switch (change->type()) {
       case AutofillChange::ADD:
         {
           sync_api::WriteNode sync_node(trans);
           std::string tag =
               AutofillModelAssociator::KeyToTag(change->key().name(),
                                                 change->key().value());
           if (!sync_node.InitUniqueByCreation(syncable::AUTOFILL,
                                               autofill_root, tag)) {
-            LOG(ERROR) << "Failed to create autofill sync node.";
-            error_handler()->OnUnrecoverableError();
+            error_handler()->OnUnrecoverableError(FROM_HERE,
+                "Failed to create autofill sync node.");
             return;
           }
 
           std::vector<base::Time> timestamps;
           if (!web_database_->GetAutofillTimestamps(
                   change->key().name(),
                   change->key().value(),
                   &timestamps)) {
-            LOG(ERROR) << "Failed to get timestamps.";
-            error_handler()->OnUnrecoverableError();
+            error_handler()->OnUnrecoverableError(FROM_HERE,
+                "Failed to get timestamps.");
             return;
           }
 
           sync_node.SetTitle(UTF16ToWide(change->key().name() +
                                          change->key().value()));
 
           WriteAutofillEntry(AutofillEntry(change->key(), timestamps),
                              &sync_node);
           model_associator_->Associate(&tag, sync_node.GetId());
         }
         break;
 
       case AutofillChange::UPDATE:
         {
           sync_api::WriteNode sync_node(trans);
           std::string tag = AutofillModelAssociator::KeyToTag(
               change->key().name(), change->key().value());
           int64 sync_id = model_associator_->GetSyncIdFromChromeId(tag);
           if (sync_api::kInvalidId == sync_id) {
-            LOG(ERROR) << "Unexpected notification for: " <<
-                       change->key().name();
-            error_handler()->OnUnrecoverableError();
+            std::string err = "Unexpected notification for: " +
+                UTF16ToUTF8(change->key().name());
+            error_handler()->OnUnrecoverableError(FROM_HERE, err);
             return;
           } else {
             if (!sync_node.InitByIdLookup(sync_id)) {
-              LOG(ERROR) << "Autofill node lookup failed.";
-              error_handler()->OnUnrecoverableError();
+              error_handler()->OnUnrecoverableError(FROM_HERE,
+                  "Autofill node lookup failed.");
               return;
             }
           }
 
           std::vector<base::Time> timestamps;
           if (!web_database_->GetAutofillTimestamps(
                    change->key().name(),
                    change->key().value(),
                    &timestamps)) {
-            LOG(ERROR) << "Failed to get timestamps.";
-            error_handler()->OnUnrecoverableError();
+            error_handler()->OnUnrecoverableError(FROM_HERE,
+                "Failed to get timestamps.");
             return;
           }
 
           WriteAutofillEntry(AutofillEntry(change->key(), timestamps),
                              &sync_node);
         }
         break;
       case AutofillChange::REMOVE: {
         std::string tag = AutofillModelAssociator::KeyToTag(
             change->key().name(), change->key().value());
         RemoveSyncNode(tag, trans);
         }
         break;
     }
   }
 }
 
 void AutofillChangeProcessor::RemoveSyncNode(const std::string& tag,
     sync_api::WriteTransaction* trans) {
   sync_api::WriteNode sync_node(trans);
   int64 sync_id = model_associator_->GetSyncIdFromChromeId(tag);
   if (sync_api::kInvalidId == sync_id) {
-    LOG(ERROR) << "Unexpected notification";
-    error_handler()->OnUnrecoverableError();
+    std::string err = "Unexpected notification for: " + tag;
+    error_handler()->OnUnrecoverableError(FROM_HERE, err);
     return;
   } else {
     if (!sync_node.InitByIdLookup(sync_id)) {
-      LOG(ERROR) << "Autofill node lookup failed.";
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+          "Autofill node lookup failed.");
       return;
     }
     model_associator_->Disassociate(sync_node.GetId());
     sync_node.Remove();
   }
 }
 
 void AutofillChangeProcessor::ApplyChangesFromSyncModel(
     const sync_api::BaseTransaction* trans,
     const sync_api::SyncManager::ChangeRecord* changes,
     int change_count) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   if (!running())
     return;
   StopObserving();
 
   sync_api::ReadNode autofill_root(trans);
   if (!autofill_root.InitByTagLookup(kAutofillTag)) {
-    LOG(ERROR) << "Autofill root node lookup failed.";
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+        "Autofill root node lookup failed.");
     return;
   }
 
   std::vector<AutofillEntry> new_entries;
   for (int i = 0; i < change_count; ++i) {
     sync_api::SyncManager::ChangeRecord::Action action(changes[i].action);
     if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE == action) {
       scoped_ptr<ExtraAutofillChangeRecordData> data(
           static_cast<ExtraAutofillChangeRecordData*>(changes[i].extra));
       DCHECK(data.get()) << "Extra autofill change record data not present!";
       const sync_pb::AutofillSpecifics* autofill(data->pre_deletion_data);
       if (autofill->has_value())
         ApplySyncAutofillEntryDelete(*autofill);
       else if (autofill->has_profile())
         ApplySyncAutofillProfileDelete(autofill->profile(), changes[i].id);
       else
         NOTREACHED() << "Autofill specifics has no data!";
       continue;
     }
 
     // Handle an update or add.
     sync_api::ReadNode sync_node(trans);
     if (!sync_node.InitByIdLookup(changes[i].id)) {
-      LOG(ERROR) << "Autofill node lookup failed.";
-      error_handler()->OnUnrecoverableError();
+      error_handler()->OnUnrecoverableError(FROM_HERE,
+          "Autofill node lookup failed.");
       return;
     }
 
     // Check that the changed node is a child of the autofills folder.
     DCHECK(autofill_root.GetId() == sync_node.GetParentId());
     DCHECK(syncable::AUTOFILL == sync_node.GetModelType());
 
     const sync_pb::AutofillSpecifics& autofill(
         sync_node.GetAutofillSpecifics());
     int64 sync_id = sync_node.GetId();
     if (autofill.has_value())
       ApplySyncAutofillEntryChange(action, autofill, &new_entries, sync_id);
     else if (autofill.has_profile())
       ApplySyncAutofillProfileChange(action, autofill.profile(), sync_id);
     else
       NOTREACHED() << "Autofill specifics has no data!";
   }
 
   if (!web_database_->UpdateAutofillEntries(new_entries)) {
-    LOG(ERROR) << "Could not update autofill entries.";
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+        "Could not update autofill entries.");
     return;
   }
 
   PostOptimisticRefreshTask();
 
   StartObserving();
 }
 
 void AutofillChangeProcessor::ApplySyncAutofillEntryDelete(
       const sync_pb::AutofillSpecifics& autofill) {
   if (!web_database_->RemoveFormElement(
       UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()))) {
-    LOG(ERROR) << "Could not remove autofill node.";
-    error_handler()->OnUnrecoverableError();
+    error_handler()->OnUnrecoverableError(FROM_HERE,
+        "Could not remove autofill node.");
     return;
   }
 }
 
 void AutofillChangeProcessor::ApplySyncAutofillEntryChange(
       sync_api::SyncManager::ChangeRecord::Action action,
       const sync_pb::AutofillSpecifics& autofill,
       std::vector<AutofillEntry>* new_entries,
       int64 sync_id) {
   DCHECK_NE(sync_api::SyncManager::ChangeRecord::ACTION_DELETE, action);
@@ skipping 143 matching lines @@
   s->set_company_name(UTF16ToUTF8(profile.GetFieldText(
       AutoFillType(COMPANY_NAME))));
   s->set_phone_fax_whole_number(UTF16ToUTF8(profile.GetFieldText(
       AutoFillType(PHONE_FAX_WHOLE_NUMBER))));
   s->set_phone_home_whole_number(UTF16ToUTF8(profile.GetFieldText(
       AutoFillType(PHONE_HOME_WHOLE_NUMBER))));
   node->SetAutofillSpecifics(autofill);
 }
 
 }  // namespace browser_sync