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

chrome/browser/sync/glue/password_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/password_model_associator.h"
 
 #include <set>
 
 #include "base/stl_util.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_store.h"
-#include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "net/base/escape.h"
 #include "webkit/glue/password_form.h"
 
 namespace browser_sync {
 
 const char kPasswordTag[] = "google_chrome_passwords";
 
 PasswordModelAssociator::PasswordModelAssociator(
     ProfileSyncService* sync_service,
     PasswordStore* password_store)
     : sync_service_(sync_service),
       password_store_(password_store),
       password_node_id_(sync_api::kInvalidId),
       abort_association_pending_(false),
       expected_loop_(MessageLoop::current()) {
   DCHECK(sync_service_);
   DCHECK(password_store_);
 #if defined(OS_MACOSX)
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 #else
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 #endif
 }
 
 PasswordModelAssociator::~PasswordModelAssociator() {}
 
-bool PasswordModelAssociator::AssociateModels(SyncError* error) {
+bool PasswordModelAssociator::AssociateModels() {
   DCHECK(expected_loop_ == MessageLoop::current());
   {
     base::AutoLock lock(abort_association_pending_lock_);
     abort_association_pending_ = false;
   }
 
   // We must not be holding a transaction when we interact with the password
   // store, as it can post tasks to the UI thread which can itself be blocked
   // on our transaction, resulting in deadlock. (http://crbug.com/70658)
   std::vector<webkit_glue::PasswordForm*> passwords;
   if (!password_store_->FillAutofillableLogins(&passwords) ||
       !password_store_->FillBlacklistLogins(&passwords)) {
     STLDeleteElements(&passwords);
-    error->Reset(FROM_HERE,
-                 "Could not get the password entries.",
-                 model_type());
+    LOG(ERROR) << "Could not get the password entries.";
     return false;
   }
 
   std::set<std::string> current_passwords;
   PasswordVector new_passwords;
   PasswordVector updated_passwords;
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     sync_api::ReadNode password_root(&trans);
     if (!password_root.InitByTagLookup(kPasswordTag)) {
-      error->Reset(FROM_HERE,
-                   "Server did not create the top-level password node. We "
-                   "might be running against an out-of-date server.",
-                   model_type());
+      LOG(ERROR) << "Server did not create the top-level password node. We "
+                 << "might be running against an out-of-date server.";
       return false;
     }
 
     for (std::vector<webkit_glue::PasswordForm*>::iterator ix =
              passwords.begin();
          ix != passwords.end(); ++ix) {
-      if (IsAbortPending()) {
-        error->Reset(FROM_HERE, "Abort pending", model_type());
+      if (IsAbortPending())
         return false;
-      }
       std::string tag = MakeTag(**ix);
 
       sync_api::ReadNode node(&trans);
       if (node.InitByClientTagLookup(syncable::PASSWORDS, tag)) {
         const sync_pb::PasswordSpecificsData& password =
             node.GetPasswordSpecifics();
         DCHECK_EQ(tag, MakeTag(password));
 
         webkit_glue::PasswordForm new_password;
 
         if (MergePasswords(password, **ix, &new_password)) {
           sync_api::WriteNode write_node(&trans);
           if (!write_node.InitByClientTagLookup(syncable::PASSWORDS, tag)) {
             STLDeleteElements(&passwords);
-            error->Reset(FROM_HERE,
-                         "Failed to edit password sync node.",
-                         model_type());
+            LOG(ERROR) << "Failed to edit password sync node.";
             return false;
           }
           WriteToSyncNode(new_password, &write_node);
           updated_passwords.push_back(new_password);
         }
 
         Associate(&tag, node.GetId());
       } else {
         sync_api::WriteNode node(&trans);
         if (!node.InitUniqueByCreation(syncable::PASSWORDS,
                                        password_root, tag)) {
           STLDeleteElements(&passwords);
-          error->Reset(FROM_HERE,
-                       "Failed to create password sync node.",
-                       model_type());
+          LOG(ERROR) << "Failed to create password sync node.";
           return false;
         }
 
         WriteToSyncNode(**ix, &node);
 
         Associate(&tag, node.GetId());
       }
 
       current_passwords.insert(tag);
     }
 
     STLDeleteElements(&passwords);
 
     int64 sync_child_id = password_root.GetFirstChildId();
     while (sync_child_id != sync_api::kInvalidId) {
       sync_api::ReadNode sync_child_node(&trans);
       if (!sync_child_node.InitByIdLookup(sync_child_id)) {
-        error->Reset(FROM_HERE, "Failed to fetch child node.", model_type());
+        LOG(ERROR) << "Failed to fetch child node.";
         return false;
       }
       const sync_pb::PasswordSpecificsData& password =
           sync_child_node.GetPasswordSpecifics();
       std::string tag = MakeTag(password);
 
       // The password only exists on the server.  Add it to the local
       // model.
       if (current_passwords.find(tag) == current_passwords.end()) {
         webkit_glue::PasswordForm new_password;
 
         CopyPassword(password, &new_password);
         Associate(&tag, sync_child_node.GetId());
         new_passwords.push_back(new_password);
       }
 
       sync_child_id = sync_child_node.GetSuccessorId();
     }
   }
 
   // We must not be holding a transaction when we interact with the password
   // store, as it can post tasks to the UI thread which can itself be blocked
   // on our transaction, resulting in deadlock. (http://crbug.com/70658)
   if (!WriteToPasswordStore(&new_passwords, &updated_passwords, NULL)) {
-    error->Reset(FROM_HERE, "Failed to write passwords.", model_type());
+    LOG(ERROR) << "Failed to write passwords.";
     return false;
   }
 
   return true;
 }
 
 bool PasswordModelAssociator::DeleteAllNodes(
     sync_api::WriteTransaction* trans) {
   DCHECK(expected_loop_ == MessageLoop::current());
   for (PasswordToSyncIdMap::iterator node_id = id_map_.begin();
        node_id != id_map_.end(); ++node_id) {
     sync_api::WriteNode sync_node(trans);
     if (!sync_node.InitByIdLookup(node_id->second)) {
       LOG(ERROR) << "Typed url node lookup failed.";
       return false;
     }
     sync_node.Remove();
   }
 
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
-bool PasswordModelAssociator::DisassociateModels(SyncError* error) {
+bool PasswordModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
   return true;
 }
 
 bool PasswordModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
   DCHECK(has_nodes);
   *has_nodes = false;
   int64 password_sync_id;
   if (!GetSyncIdForTaggedNode(kPasswordTag, &password_sync_id)) {
@@ skipping 224 matching lines @@
     const std::string& password_element,
     const std::string& signon_realm) {
   return EscapePath(origin_url) + "|" +
          EscapePath(username_element) + "|" +
          EscapePath(username_value) + "|" +
          EscapePath(password_element) + "|" +
          EscapePath(signon_realm);
 }
 
 }  // namespace browser_sync