[Sync] - Upload the callstacks for errors so that the line number of error is in callstack.

chrome/browser/sync/glue/session_model_associator.cc

 // Copyright (c) 2012 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>
 
@@ skipping 64 matching lines @@
   return internal::IsTabletUi() ?
       sync_pb::SessionHeader_DeviceType_TYPE_TABLET :
       sync_pb::SessionHeader_DeviceType_TYPE_PHONE;
 #else
   return sync_pb::SessionHeader_DeviceType_TYPE_OTHER;
 #endif
 }
 
 }  // namespace
 
-SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service)
+SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service,
+    DataTypeErrorHandler* error_handler)
     : tab_pool_(sync_service),
       local_session_syncid_(sync_api::kInvalidId),
       sync_service_(sync_service),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       setup_for_test_(false),
       waiting_for_change_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(test_weak_factory_(this)),
       profile_(sync_service->profile()),
-      pref_service_(profile_->GetPrefs()) {
+      pref_service_(profile_->GetPrefs()),
+      error_handler_(error_handler) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_service_);
   DCHECK(profile_);
   if (pref_service_->FindPreference(kSyncSessionsGUID) == NULL) {
     pref_service_->RegisterStringPref(kSyncSessionsGUID,
                                       std::string(),
                                       PrefService::UNSYNCABLE_PREF);
   }
 }
 
 SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service,
                                                bool setup_for_test)
     : tab_pool_(sync_service),
       local_session_syncid_(sync_api::kInvalidId),
       sync_service_(sync_service),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       setup_for_test_(setup_for_test),
       waiting_for_change_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(test_weak_factory_(this)),
       profile_(sync_service->profile()),
-      pref_service_(NULL)  {
+      pref_service_(NULL),
+      error_handler_(NULL) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_service_);
   DCHECK(profile_);
   DCHECK(setup_for_test);
 }
 
 SessionModelAssociator::~SessionModelAssociator() {
   DCHECK(CalledOnValidThread());
 }
 
@@ skipping 132 matching lines @@
             &synced_session_tracker_);
       }
     }
   }
   // Free memory for closed windows and tabs.
   synced_session_tracker_.CleanupSession(local_tag);
 
   sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::WriteNode header_node(&trans);
   if (!header_node.InitByIdLookup(local_session_syncid_)) {
-    error->Reset(FROM_HERE,
-                 "Failed to load local session header node.",
-                 model_type());
+    if (error) {
+      *error = error_handler_->CreateAndUploadError(
+           FROM_HERE,
+           "Failed to load local session header node.",
+           model_type());
+    }
     return false;
   }
   header_node.SetSessionSpecifics(specifics);
   if (waiting_for_change_) QuitLoopForSubtleTesting();
   return true;
 }
 
 // Static.
 bool SessionModelAssociator::ShouldSyncWindow(
     const SyncedWindowDelegate* window) {
@@ skipping 34 matching lines @@
   }
 
   if (!ShouldSyncTab(tab))
     return true;
 
   TabLinksMap::const_iterator tablink = tab_map_.find(id);
   if (tablink == tab_map_.end()) {
     // This is a new tab, get a sync node for it.
     sync_id = tab_pool_.GetFreeTabNode();
     if (sync_id == sync_api::kInvalidId) {
-      error->Reset(FROM_HERE,
-                   "Received invalid tab node from tab pool. Reassociation "
-                       "needed.",
-                    model_type());
+      if (error) {
+        *error = error_handler_->CreateAndUploadError(
+            FROM_HERE,
+            "Received invalid tab node from tab pool.",
+            model_type());
+      }
       return false;
     }
   } else {
     // This tab is already associated with a sync node, reuse it.
     sync_id = tablink->second.sync_id();
   }
 
   DVLOG(1) << "Reloading tab " << id << " from window " << tab.GetWindowId();
   const SyncedWindowDelegate* window =
       SyncedWindowDelegate::FindSyncedWindowDelegateWithId(
@@ skipping 52 matching lines @@
   synced_session_tracker_.GetSession(GetCurrentMachineTag())->modified_time =
       base::Time::Now();
   PopulateSessionTabFromSpecifics(*tab_s,
                                   base::Time::Now(),
                                   session_tab);
 
   // Write into the actual sync model.
   sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   sync_api::WriteNode tab_node(&trans);
   if (!tab_node.InitByIdLookup(sync_id)) {
-    error->Reset(FROM_HERE, "Failed to look up local tab node", model_type());
+    if (error) {
+      *error = error_handler_->CreateAndUploadError(
+          FROM_HERE,
+          "Failed to look up local tab node",
+          model_type());
+    }
     return false;
   }
   tab_node.SetSessionSpecifics(session_s);
   return true;
 }
 
 // Static
 // TODO(zea): perhaps sync state (scroll position, form entries, etc.) as well?
 // See http://crbug.com/67068.
 void SessionModelAssociator::PopulateSessionSpecificsNavigation(
@@ skipping 74 matching lines @@
 void SessionModelAssociator::Associate(const SyncedTabDelegate* tab,
                                        int64 sync_id) {
   NOTIMPLEMENTED();
 }
 
 void SessionModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
-bool SessionModelAssociator::AssociateModels(SyncError* error) {
+SyncError SessionModelAssociator::AssociateModels() {
   DCHECK(CalledOnValidThread());
+  SyncError error;
 
   // 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(syncable::ModelTypeToRootTag(model_type()))) {
-      error->Reset(FROM_HERE, kNoSessionsFolderError, model_type());
-      return false;
+      return error_handler_->CreateAndUploadError(
+          FROM_HERE,
+          kNoSessionsFolderError,
+          model_type());
     }
 
     // Make sure we have a machine tag.
     if (current_machine_tag_.empty()) {
       InitializeCurrentMachineTag(&trans);
       // The session name is retrieved asynchronously so it might not come back
       // for the writing of the session. However, we write to the session often
       // enough (on every navigation) that we'll pick it up quickly.
       InitializeCurrentSessionName();
     }
     synced_session_tracker_.SetLocalSessionTag(current_machine_tag_);
-    if (!UpdateAssociationsFromSyncModel(root, &trans, error))
-      return false;
+    if (!UpdateAssociationsFromSyncModel(root, &trans, &error)) {
+      DCHECK(error.IsSet());
+      return error;
+    }
 
     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(SESSIONS, root,
                                            current_machine_tag_)) {
-        error->Reset(FROM_HERE,
-                     "Failed to create sessions header sync node.",
-                     model_type());
-        return false;
+        return error_handler_->CreateAndUploadError(
+            FROM_HERE,
+            "Failed to create sessions header sync node.",
+            model_type());
       }
       write_node.SetTitle(UTF8ToWide(current_machine_tag_));
       local_session_syncid_ = write_node.GetId();
     }
   }
 
   // Check if anything has changed on the client side.
-  if (!UpdateSyncModelDataFromClient(error))
-    return false;
+  if (!UpdateSyncModelDataFromClient(&error)) {
+    DCHECK(error.IsSet());
+    return error;
+  }
 
   DVLOG(1) << "Session models associated.";
-  return true;
+  DCHECK(!error.IsSet());
+  return error;
 }
 
-bool SessionModelAssociator::DisassociateModels(SyncError* error) {
+SyncError SessionModelAssociator::DisassociateModels() {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "Disassociating local session " << GetCurrentMachineTag();
   synced_session_tracker_.Clear();
   tab_map_.clear();
   tab_pool_.clear();
   local_session_syncid_ = sync_api::kInvalidId;
   current_machine_tag_ = "";
   current_session_name_ = "";
 
   // There is no local model stored with which to disassociate, just notify
   // foreign session handlers.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
       content::Source<Profile>(sync_service_->profile()),
       content::NotificationService::NoDetails());
-  return true;
+  return SyncError();
 }
 
 void SessionModelAssociator::InitializeCurrentMachineTag(
     sync_api::WriteTransaction* trans) {
   DCHECK(CalledOnValidThread());
   DCHECK(current_machine_tag_.empty());
   std::string persisted_guid;
   if (pref_service_)
     persisted_guid = pref_service_->GetString(kSyncSessionsGUID);
   if (!persisted_guid.empty()) {
@@ skipping 38 matching lines @@
     SyncError* error) {
   DCHECK(CalledOnValidThread());
   DCHECK(tab_pool_.empty());
   DCHECK_EQ(local_session_syncid_, sync_api::kInvalidId);
 
   // Iterate through the nodes and associate any foreign sessions.
   int64 id = root.GetFirstChildId();
   while (id != sync_api::kInvalidId) {
     sync_api::WriteNode sync_node(trans);
     if (!sync_node.InitByIdLookup(id)) {
-      error->Reset(FROM_HERE, "Failed to load sync node", model_type());
+      if (error) {
+        *error = error_handler_->CreateAndUploadError(
+            FROM_HERE,
+            "Failed to load sync node",
+            model_type());
+      }
       return false;
     }
     int64 next_id = sync_node.GetSuccessorId();
 
     const sync_pb::SessionSpecifics& specifics =
         sync_node.GetSessionSpecifics();
     const base::Time& modification_time = sync_node.GetModificationTime();
     if (specifics.session_tag() != GetCurrentMachineTag()) {
       AssociateForeignSpecifics(specifics, modification_time);
     } else {
@@ skipping 521 matching lines @@
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncable::ModelTypeSet encrypted_types =
       sync_api::GetEncryptedTypes(&trans);
   return !encrypted_types.Has(SESSIONS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync