Revert 94128 - [Sync] Refactor sync datatype error handling.

chrome/browser/sync/glue/autofill_profile_model_associator.cc

 // Copyright (c) 2011 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_profile_model_associator.h"
 
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/autofill_profile_change_processor.h"
 #include "chrome/browser/sync/glue/do_optimistic_refresh_task.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/common/guid.h"
 
 using sync_api::ReadNode;
 namespace browser_sync {
 
 const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
@@ skipping 110 matching lines @@
     std::vector<AutofillProfile*>* profiles) {
   if (IsAbortPending())
     return false;
 
   if (!web_database_->GetAutofillTable()->GetAutofillProfiles(profiles))
     return false;
 
   return true;
 }
 
-bool AutofillProfileModelAssociator::AssociateModels(SyncError* error) {
+bool AutofillProfileModelAssociator::AssociateModels() {
   VLOG(1) << "Associating Autofill Models";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   {
     base::AutoLock lock(abort_association_pending_lock_);
     abort_association_pending_ = false;
   }
 
   ScopedVector<AutofillProfile> profiles;
 
   if (!LoadAutofillData(&profiles.get())) {
-    error->Reset(FROM_HERE,
-                 "Could not get the autofill data from WebDatabase.",
-                 model_type());
+    LOG(ERROR) << "Could not get the autofill data from WebDatabase.";
     return false;
   }
 
   VLOG(1) << "[AUTOFILL MIGRATION]"
           << " Now associating to the new autofill profile model associator"
           << " root node";
   DataBundle bundle;
   {
     // The write transaction lock is held inside this block.
     // We do all the web db operations outside this block.
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(kAutofillProfileTag)) {
-      error->Reset(FROM_HERE,
-                   "Server did not create the top-level autofill node. We "
-                   "might be running against an out-of-date server.",
-                   model_type());
+      LOG(ERROR) << "Server did not create the top-level autofill node. We "
+                 << "might be running against an out-of-date server.";
       return false;
     }
 
     if (!TraverseAndAssociateChromeAutofillProfiles(&trans, autofill_root,
             profiles.get(), &bundle.current_profiles,
             &bundle.updated_profiles,
             &bundle.new_profiles,
             &bundle.profiles_to_delete) ||
         !TraverseAndAssociateAllSyncNodes(&trans, autofill_root, &bundle)) {
-      error->Reset(FROM_HERE,
-                   "Failed to associate all sync nodes.",
-                   model_type());
       return false;
     }
   }
 
   if (!SaveChangesToWebData(bundle)) {
-    error->Reset(FROM_HERE, "Failed to update webdata.", model_type());
+    LOG(ERROR) << "Failed to update autofill entries.";
     return false;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       new DoOptimisticRefreshForAutofill(personal_data_));
   return true;
 }
 
-bool AutofillProfileModelAssociator::DisassociateModels(SyncError* error) {
+bool AutofillProfileModelAssociator::DisassociateModels() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
 // Helper to compare the local value and cloud value of a field, merge into
 // the local value if they differ, and return whether the merge happened.
 bool AutofillProfileModelAssociator::MergeField(FormGroup* f,
     AutofillFieldType t,
@@ skipping 295 matching lines @@
 bool AutofillProfileModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   syncable::ModelTypeSet encrypted_types;
   encrypted_types = sync_api::GetEncryptedTypes(&trans);
   return encrypted_types.count(syncable::AUTOFILL_PROFILE) == 0 ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync