sync: Add location info to unrecoverable error.

chrome/browser/sync/profile_sync_service.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <string>
 #include <map>
 
@@ skipping 187 matching lines @@
       const browser_sync::SyncBackendHost::StatusSummary& summary);
 
   // Returns true if the SyncBackendHost has told us it's ready to accept
   // changes.
   // TODO(timsteele): What happens if the bookmark model is loaded, a change
   // takes place, and the backend isn't initialized yet?
   bool sync_initialized() const { return backend_initialized_; }
   bool unrecoverable_error_detected() const {
     return unrecoverable_error_detected_;
   }
+  const std::string& unrecoverable_error_message() {
+    return unrecoverable_error_message_;
+  }
+  tracked_objects::Location unrecoverable_error_location() {
+    return unrecoverable_error_location_.get() ?
+        *unrecoverable_error_location_.get() : tracked_objects::Location();
+  }
 
   bool UIShouldDepictAuthInProgress() const {
     return is_auth_in_progress_;
   }
 
   // A timestamp marking the last time the service observed a transition from
   // the SYNCING state to the READY state. Note that this does not reflect the
   // last time we polled the server to see if there were any changes; the
   // timestamp is only snapped when syncing takes place and we download or
   // upload some bookmark entity.
@@ skipping 21 matching lines @@
 
   // Record stats on various events.
   static void SyncEvent(SyncEventCodes code);
 
   // Returns whether sync is enabled.  Sync can be enabled/disabled both
   // at compile time (e.g., on a per-OS basis) or at run time (e.g.,
   // command-line switches).
   static bool IsSyncEnabled();
 
   // UnrecoverableErrorHandler implementation.
-  virtual void OnUnrecoverableError();
+  virtual void OnUnrecoverableError(
+      const tracked_objects::Location& from_here,
+      const std::string& message);
 
   browser_sync::SyncBackendHost* backend() { return backend_.get(); }
 
   virtual void ActivateDataType(
       browser_sync::DataTypeController* data_type_controller,
       browser_sync::ChangeProcessor* change_processor);
   virtual void DeactivateDataType(
       browser_sync::DataTypeController* data_type_controller,
       browser_sync::ChangeProcessor* change_processor);
 
@@ skipping 139 matching lines @@
   // As its name suggests, this should NOT be used for anything other than UI.
   bool is_auth_in_progress_;
 
   SyncSetupWizard wizard_;
 
   // True if an unrecoverable error (e.g. violation of an assumed invariant)
   // occurred during syncer operation.  This value should be checked before
   // doing any work that might corrupt things further.
   bool unrecoverable_error_detected_;
 
+  // A message sent when an unrecoverable error occurred.
+  std::string unrecoverable_error_message_;
+  scoped_ptr<tracked_objects::Location> unrecoverable_error_location_;
+
   // Which peer-to-peer notification method to use.
   browser_sync::NotificationMethod notification_method_;
 
   // Manages the start and stop of the various data types.
   scoped_ptr<browser_sync::DataTypeManager> data_type_manager_;
 
   ObserverList<Observer> observers_;
 
   NotificationRegistrar registrar_;
 
   ScopedRunnableMethodFactory<ProfileSyncService>
     scoped_runnable_method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_