Introduce the plumbing necessary to report Unrecoverable error from model safe workers.

chrome/browser/sync/glue/sync_backend_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/internal_api/configure_reason.h"
 #include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/notifier/sync_notifier_factory.h"
 #include "chrome/browser/sync/protocol/sync_protocol_error.h"
 #include "chrome/browser/sync/syncable/model_type.h"
+#include "chrome/browser/sync/unrecoverable_error_handler.h"
 #include "chrome/browser/sync/util/weak_handle.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_context_getter.h"
 
 class MessageLoop;
 class Profile;
 
 namespace browser_sync {
 
 namespace sessions {
 struct SyncSessionSnapshot;
 }
 
 class ChangeProcessor;
 class JsBackend;
 class JsEventHandler;
 class SyncBackendRegistrar;
 class SyncPrefs;
 
 // SyncFrontend is the interface used by SyncBackendHost to communicate with
 // the entity that created it and, presumably, is interested in sync-related
 // activity.
 // NOTE: All methods will be invoked by a SyncBackendHost on the same thread
 // used to create that SyncBackendHost.
-class SyncFrontend {
+class SyncFrontend : public browser_sync::UnrecoverableErrorHandler {
  public:
   SyncFrontend() {}
 
   // The backend has completed initialization and it is now ready to
   // accept and process changes.  If success is false, initialization
   // wasn't able to be completed and should be retried.
   //
   // |js_backend| is what about:sync interacts with; it's different
   // from the 'Backend' in 'OnBackendInitialized' (unfortunately).  It
   // is initialized only if |success| is true.
@@ skipping 223 matching lines @@
     virtual void OnPassphraseAccepted(
         const std::string& bootstrap_token) OVERRIDE;
     virtual void OnStopSyncingPermanently() OVERRIDE;
     virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
     virtual void OnClearServerDataFailed() OVERRIDE;
     virtual void OnClearServerDataSucceeded() OVERRIDE;
     virtual void OnEncryptionComplete(
         const syncable::ModelTypeSet& encrypted_types);
     virtual void OnActionableError(
         const browser_sync::SyncProtocolError& sync_error);
+    virtual void OnUnrecoverableError(
+        const tracked_objects::Location& location,
+        const std::string& message) OVERRIDE;
 
     struct DoInitializeOptions {
       DoInitializeOptions(
           MessageLoop* sync_loop,
           SyncBackendRegistrar* registrar,
           const WeakHandle<JsEventHandler>& event_handler,
           const GURL& service_url,
           const scoped_refptr<net::URLRequestContextGetter>&
               request_context_getter,
           const sync_api::SyncCredentials& credentials,
@@ skipping 117 matching lines @@
     // This is called from the thread we were created on (which is the
     // SyncBackendHost |sync_thread_|), using a repeating timer that is kicked
     // off as soon as the SyncManager tells us it completed
     // initialization.
     void SaveChanges();
 
     // Let the front end handle the actionable error event.
     void HandleActionableErrorEventOnFrontendLoop(
         const browser_sync::SyncProtocolError& sync_error);
 
+    // Informs the front end of the unrecoverable error.
+    void HandleUnrecoverableErrorOnFrontendLoop(
+        const tracked_objects::Location& location,
+        const std::string& message);
+
     // Dispatched to from OnAuthError to handle updating frontend UI
     // components.
     void HandleAuthErrorEventOnFrontendLoop(
         const GoogleServiceAuthError& new_auth_error);
 
     // Invoked when a passphrase is required to decrypt a set of Nigori keys,
     // or for encrypting. |reason| denotes why the passhrase was required.
     void NotifyPassphraseRequired(sync_api::PassphraseRequiredReason reason);
 
     // Invoked when the passphrase provided by the user has been accepted.
@@ skipping 139 matching lines @@
 
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   scoped_ptr<sessions::SyncSessionSnapshot> last_snapshot_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_