[Sync] Refactor sync datatype error handling.

chrome/browser/sync/glue/autofill_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_model_associator.h"
 
 #include <functional>
 #include <vector>
 
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/autofill_change_processor.h"
 #include "chrome/browser/sync/glue/autofill_profile_model_associator.h"
 #include "chrome/browser/sync/glue/do_optimistic_refresh_task.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/common/guid.h"
 #include "content/browser/browser_thread.h"
 #include "net/base/escape.h"
@@ skipping 102 matching lines @@
     return false;
 
   if (IsAbortPending())
     return false;
   if (!web_database_->GetAutofillTable()->GetAutofillProfiles(profiles))
     return false;
 
   return true;
 }
 
-bool AutofillModelAssociator::AssociateModels() {
+bool AutofillModelAssociator::AssociateModels(SyncError* error) {
   VLOG(1) << "Associating Autofill Models";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   {
     base::AutoLock lock(abort_association_pending_lock_);
     abort_association_pending_ = false;
   }
 
   // TODO(zork): Attempt to load the model association from storage.
   std::vector<AutofillEntry> entries;
   ScopedVector<AutofillProfile> profiles;
 
   if (!LoadAutofillData(&entries, &profiles.get())) {
-    LOG(ERROR) << "Could not get the autofill data from WebDatabase.";
+    error->Reset(FROM_HERE,
+                 "Could not get the autofill data from WebDatabase.",
+                 model_type());
     return false;
   }
 
   DataBundle bundle;
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
     sync_api::ReadNode autofill_root(&trans);
     if (!autofill_root.InitByTagLookup(kAutofillTag)) {
-      LOG(ERROR) << "Server did not create the top-level autofill node. We "
-                 << "might be running against an out-of-date server.";
+      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());
       return false;
     }
 
     if (!TraverseAndAssociateChromeAutofillEntries(&trans, autofill_root,
         entries, &bundle.current_entries, &bundle.new_entries)) {
+      error->Reset(FROM_HERE, "Failed to associate entries.", model_type());
       return false;
     }
 
     if (!TraverseAndAssociateAllSyncNodes(
         &trans,
         autofill_root,
         &bundle,
         profiles.get())) {
+      error->Reset(FROM_HERE, "Failed to associate sync nodes.", model_type());
       return false;
     }
   }
 
   // Since we're on the DB thread, we don't have to worry about updating
   // the autofill database after closing the write transaction, since
   // this is the only thread that writes to the database.  We also don't have
   // to worry about the sync model getting out of sync, because changes are
   // propagated to the ChangeProcessor on this thread.
   if (!SaveChangesToWebData(bundle)) {
-    LOG(ERROR) << "Failed to update autofill entries.";
+    error->Reset(FROM_HERE, "Failed to update webdata.", model_type());
     return false;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       new DoOptimisticRefreshForAutofill(personal_data_));
   return true;
 }
 
 bool AutofillModelAssociator::SaveChangesToWebData(const DataBundle& bundle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
@@ skipping 140 matching lines @@
       DCHECK(false) << "Guid generated is invalid " << guid;
       return;
     }
     Associate(&guid, node.GetId());
     AutofillProfile* p = new AutofillProfile(guid);
     FillProfileWithServerData(p, profile);
     bundle->new_profiles.push_back(p);
   }
 }
 
-bool AutofillModelAssociator::DisassociateModels() {
+bool AutofillModelAssociator::DisassociateModels(SyncError* error) {
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
 bool AutofillModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(has_nodes);
   *has_nodes = false;
   int64 autofill_sync_id;
   if (!GetSyncIdForTaggedNode(kAutofillTag, &autofill_sync_id)) {
@@ skipping 147 matching lines @@
 bool AutofillModelAssociator::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) == 0 ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync