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

chrome/browser/sync/glue/session_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/session_model_associator.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/tracked.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/sessions/session_service_factory.h"
-#include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/common/notification_details.h"
@@ skipping 373 matching lines @@
         sync_pb::TabNavigation_PageTransition_TYPED);
   }
 }
 
 void SessionModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
   // TODO(zea): we will need this once we support deleting foreign sessions.
 }
 
-bool SessionModelAssociator::AssociateModels(SyncError* error) {
+bool SessionModelAssociator::AssociateModels() {
   DCHECK(CalledOnValidThread());
 
   // Ensure that we disassociated properly, otherwise memory might leak.
   DCHECK(synced_session_tracker_.empty());
   DCHECK_EQ(0U, tab_pool_.capacity());
 
   local_session_syncid_ = sync_api::kInvalidId;
 
   // Read any available foreign sessions and load any session data we may have.
   // If we don't have any local session data in the db, create a header node.
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
     sync_api::ReadNode root(&trans);
     if (!root.InitByTagLookup(kSessionsTag)) {
-      error->Reset(FROM_HERE, kNoSessionsFolderError, model_type());
+      LOG(ERROR) << kNoSessionsFolderError;
       return false;
     }
 
     // Make sure we have a machine tag.
     if (current_machine_tag_.empty())
       InitializeCurrentMachineTag(&trans);
     synced_session_tracker_.SetLocalSessionTag(current_machine_tag_);
     UpdateAssociationsFromSyncModel(root, &trans);
 
     if (local_session_syncid_ == sync_api::kInvalidId) {
       // The sync db didn't have a header node for us, we need to create one.
       sync_api::WriteNode write_node(&trans);
       if (!write_node.InitUniqueByCreation(syncable::SESSIONS, root,
           current_machine_tag_)) {
-        error->Reset(FROM_HERE,
-                     "Failed to create sessions header sync node.",
-                     model_type());
+        LOG(ERROR) << "Failed to create sessions header sync node.";
         return false;
       }
       write_node.SetTitle(UTF8ToWide(current_machine_tag_));
       local_session_syncid_ = write_node.GetId();
     }
   }
 
   // Check if anything has changed on the client side.
   UpdateSyncModelDataFromClient();
 
   VLOG(1) << "Session models associated.";
 
   return true;
 }
 
-bool SessionModelAssociator::DisassociateModels(SyncError* error) {
+bool SessionModelAssociator::DisassociateModels() {
   DCHECK(CalledOnValidThread());
   synced_session_tracker_.clear();
   tab_map_.clear();
   tab_pool_.clear();
   local_session_syncid_ = sync_api::kInvalidId;
 
   // There is no local model stored with which to disassociate, just notify
   // foreign session handlers.
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
@@ skipping 586 matching lines @@
 bool SessionModelAssociator::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::SESSIONS) == 0 ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync